summaryrefslogtreecommitdiff
path: root/indra/llui
diff options
context:
space:
mode:
Diffstat (limited to 'indra/llui')
-rw-r--r--indra/llui/llbutton.cpp18
-rw-r--r--indra/llui/lllayoutstack.cpp829
-rw-r--r--indra/llui/lllayoutstack.h94
-rw-r--r--indra/llui/llmenugl.cpp7
-rw-r--r--indra/llui/llpanel.h2
-rw-r--r--indra/llui/llresizebar.cpp4
-rw-r--r--indra/llui/llresizebar.h1
-rw-r--r--indra/llui/llscrollcontainer.cpp99
-rw-r--r--indra/llui/lltabcontainer.cpp13
-rw-r--r--indra/llui/lltextbase.cpp42
-rw-r--r--indra/llui/lltextbase.h2
-rw-r--r--indra/llui/lltexteditor.cpp26
-rw-r--r--indra/llui/lltexteditor.h5
-rw-r--r--indra/llui/lltoolbar.cpp9
-rw-r--r--indra/llui/lltoolbar.h1
-rw-r--r--indra/llui/llview.cpp11
-rw-r--r--indra/llui/llview.h2
-rw-r--r--indra/llui/llwindowshade.cpp210
-rw-r--r--indra/llui/llwindowshade.h16
19 files changed, 853 insertions, 538 deletions
diff --git a/indra/llui/llbutton.cpp b/indra/llui/llbutton.cpp
index 93d8282aa7..f0d92d597a 100644
--- a/indra/llui/llbutton.cpp
+++ b/indra/llui/llbutton.cpp
@@ -589,15 +589,23 @@ void LLButton::getOverlayImageSize(S32& overlay_width, S32& overlay_height)
// virtual
void LLButton::draw()
{
+ static LLCachedControl<bool> sEnableButtonFlashing(*LLUI::sSettingGroups["config"], "EnableButtonFlashing", true);
F32 alpha = mUseDrawContextAlpha ? getDrawContext().mAlpha : getCurrentTransparency();
bool flash = FALSE;
- if( mFlashing )
+ if( mFlashing)
{
- F32 elapsed = mFlashingTimer.getElapsedTimeF32();
- S32 flash_count = S32(elapsed * mButtonFlashRate * 2.f);
- // flash on or off?
- flash = (flash_count % 2 == 0) || flash_count > S32((F32)mButtonFlashCount * 2.f);
+ if ( sEnableButtonFlashing)
+ {
+ F32 elapsed = mFlashingTimer.getElapsedTimeF32();
+ S32 flash_count = S32(elapsed * mButtonFlashRate * 2.f);
+ // flash on or off?
+ flash = (flash_count % 2 == 0) || flash_count > S32((F32)mButtonFlashCount * 2.f);
+ }
+ else
+ { // otherwise just highlight button in flash color
+ flash = true;
+ }
}
bool pressed_by_keyboard = FALSE;
diff --git a/indra/llui/lllayoutstack.cpp b/indra/llui/lllayoutstack.cpp
index 0e7060e22c..2f1c2a47c9 100644
--- a/indra/llui/lllayoutstack.cpp
+++ b/indra/llui/lllayoutstack.cpp
@@ -34,6 +34,10 @@
#include "llpanel.h"
#include "llresizebar.h"
#include "llcriticaldamp.h"
+#include "boost/foreach.hpp"
+
+static const F32 MIN_FRACTIONAL_SIZE = 0.0001f;
+static const F32 MAX_FRACTIONAL_SIZE = 1.f;
static LLDefaultChildRegistry::Register<LLLayoutStack> register_layout_stack("layout_stack");
static LLLayoutStack::LayoutStackRegistry::Register<LLLayoutPanel> register_layout_panel("layout_panel");
@@ -49,39 +53,29 @@ void LLLayoutStack::OrientationNames::declareValues()
//
LLLayoutPanel::Params::Params()
: expanded_min_dim("expanded_min_dim", 0),
- min_dim("min_dim", 0),
- max_dim("max_dim", S32_MAX),
- user_resize("user_resize", true),
+ min_dim("min_dim", -1),
+ user_resize("user_resize", false),
auto_resize("auto_resize", true)
{
addSynonym(min_dim, "min_width");
addSynonym(min_dim, "min_height");
- addSynonym(max_dim, "max_width");
- addSynonym(max_dim, "max_height");
}
LLLayoutPanel::LLLayoutPanel(const Params& p)
: LLPanel(p),
- mExpandedMinDimSpecified(false),
- mExpandedMinDim(p.min_dim),
+ mExpandedMinDim(p.expanded_min_dim.isProvided() ? p.expanded_min_dim : p.min_dim),
mMinDim(p.min_dim),
- mMaxDim(p.max_dim),
mAutoResize(p.auto_resize),
mUserResize(p.user_resize),
mCollapsed(FALSE),
mCollapseAmt(0.f),
mVisibleAmt(1.f), // default to fully visible
mResizeBar(NULL),
- mFractionalSize(0.f),
+ mFractionalSize(MIN_FRACTIONAL_SIZE),
+ mTargetDim(0),
+ mIgnoreReshape(false),
mOrientation(LLLayoutStack::HORIZONTAL)
{
- // Set the expanded min dim if it is provided, otherwise it gets the p.min_dim value
- if (p.expanded_min_dim.isProvided())
- {
- mExpandedMinDimSpecified = true;
- mExpandedMinDim = p.expanded_min_dim();
- }
-
// panels initialized as hidden should not start out partially visible
if (!getVisible())
{
@@ -103,33 +97,83 @@ LLLayoutPanel::~LLLayoutPanel()
mResizeBar = NULL;
}
-void LLLayoutPanel::reshape(S32 width, S32 height, BOOL called_from_parent)
+F32 LLLayoutPanel::getAutoResizeFactor() const
+{
+ return mVisibleAmt * (1.f - mCollapseAmt);
+}
+
+F32 LLLayoutPanel::getVisibleAmount() const
+{
+ return mVisibleAmt;
+}
+
+S32 LLLayoutPanel::getLayoutDim() const
+{
+ return llround((F32)((mOrientation == LLLayoutStack::HORIZONTAL)
+ ? getRect().getWidth()
+ : getRect().getHeight()));
+}
+
+S32 LLLayoutPanel::getVisibleDim() const
+{
+ F32 min_dim = getRelevantMinDim();
+ return llround(mVisibleAmt
+ * (min_dim
+ + (((F32)mTargetDim - min_dim) * (1.f - mCollapseAmt))));
+}
+
+void LLLayoutPanel::setOrientation( LLLayoutStack::ELayoutOrientation orientation )
+{
+ mOrientation = orientation;
+ S32 layout_dim = llround((F32)((mOrientation == LLLayoutStack::HORIZONTAL)
+ ? getRect().getWidth()
+ : getRect().getHeight()));
+
+ mTargetDim = llmax(layout_dim, getMinDim());
+}
+
+void LLLayoutPanel::setVisible( BOOL visible )
{
- if (mOrientation == LLLayoutStack::HORIZONTAL)
+ if (visible != getVisible())
{
- mFractionalSize += width - llround(mFractionalSize);
+ LLLayoutStack* stackp = dynamic_cast<LLLayoutStack*>(getParent());
+ if (stackp)
+ {
+ stackp->mNeedsLayout = true;
+ }
}
- else
+ LLPanel::setVisible(visible);
+}
+
+void LLLayoutPanel::reshape( S32 width, S32 height, BOOL called_from_parent /*= TRUE*/ )
+{
+ if (width == getRect().getWidth() && height == getRect().getHeight()) return;
+
+ if (!mIgnoreReshape && mAutoResize == false)
{
- mFractionalSize += height - llround(mFractionalSize);
+ mTargetDim = (mOrientation == LLLayoutStack::HORIZONTAL) ? width : height;
+ LLLayoutStack* stackp = dynamic_cast<LLLayoutStack*>(getParent());
+ if (stackp)
+ {
+ stackp->mNeedsLayout = true;
+ }
}
LLPanel::reshape(width, height, called_from_parent);
}
-F32 LLLayoutPanel::getCollapseFactor()
+void LLLayoutPanel::handleReshape(const LLRect& new_rect, bool by_user)
{
- if (mOrientation == LLLayoutStack::HORIZONTAL)
+ LLLayoutStack* stackp = dynamic_cast<LLLayoutStack*>(getParent());
+ if (stackp)
{
- F32 collapse_amt =
- clamp_rescale(mCollapseAmt, 0.f, 1.f, 1.f, (F32)getRelevantMinDim() / (F32)llmax(1, getRect().getWidth()));
- return mVisibleAmt * collapse_amt;
- }
- else
- {
- F32 collapse_amt =
- clamp_rescale(mCollapseAmt, 0.f, 1.f, 1.f, llmin(1.f, (F32)getRelevantMinDim() / (F32)llmax(1, getRect().getHeight())));
- return mVisibleAmt * collapse_amt;
+ stackp->mNeedsLayout = true;
+ if (by_user)
+ {
+ // tell layout stack to account for new shape
+ stackp->updatePanelRect(this, new_rect);
+ }
}
+ LLPanel::handleReshape(new_rect, by_user);
}
//
@@ -142,20 +186,21 @@ LLLayoutStack::Params::Params()
clip("clip", true),
open_time_constant("open_time_constant", 0.02f),
close_time_constant("close_time_constant", 0.03f),
+ resize_bar_overlap("resize_bar_overlap", 1),
border_size("border_size", LLCachedControl<S32>(*LLUI::sSettingGroups["config"], "UIResizeBarHeight", 0))
{}
LLLayoutStack::LLLayoutStack(const LLLayoutStack::Params& p)
: LLView(p),
- mMinWidth(0),
- mMinHeight(0),
mPanelSpacing(p.border_size),
mOrientation(p.orientation),
mAnimate(p.animate),
mAnimatedThisFrame(false),
+ mNeedsLayout(true),
mClip(p.clip),
mOpenTimeConstant(p.open_time_constant),
- mCloseTimeConstant(p.close_time_constant)
+ mCloseTimeConstant(p.close_time_constant),
+ mResizeBarOverlap(p.resize_bar_overlap)
{}
LLLayoutStack::~LLLayoutStack()
@@ -169,26 +214,26 @@ void LLLayoutStack::draw()
{
updateLayout();
- e_panel_list_t::iterator panel_it;
- for (panel_it = mPanels.begin(); panel_it != mPanels.end(); ++panel_it)
+ // always clip to stack itself
+ LLLocalClipRect clip(getLocalRect());
+ BOOST_FOREACH(LLLayoutPanel* panelp, mPanels)
{
// clip to layout rectangle, not bounding rectangle
- LLRect clip_rect = (*panel_it)->getRect();
+ LLRect clip_rect = panelp->getRect();
// scale clipping rectangle by visible amount
if (mOrientation == HORIZONTAL)
{
- clip_rect.mRight = clip_rect.mLeft + llround((F32)clip_rect.getWidth() * (*panel_it)->getCollapseFactor());
+ clip_rect.mRight = clip_rect.mLeft + panelp->getVisibleDim();
}
else
{
- clip_rect.mBottom = clip_rect.mTop - llround((F32)clip_rect.getHeight() * (*panel_it)->getCollapseFactor());
+ clip_rect.mBottom = clip_rect.mTop - panelp->getVisibleDim();
}
- LLPanel* panelp = (*panel_it);
-
- LLLocalClipRect clip(clip_rect, mClip);
- // only force drawing invisible children if visible amount is non-zero
- drawChild(panelp, 0, 0, !clip_rect.isEmpty());
+ {LLLocalClipRect clip(clip_rect, mClip);
+ // only force drawing invisible children if visible amount is non-zero
+ drawChild(panelp, 0, 0, !clip_rect.isEmpty());
+ }
}
mAnimatedThisFrame = false;
}
@@ -201,12 +246,10 @@ void LLLayoutStack::removeChild(LLView* view)
{
mPanels.erase(std::find(mPanels.begin(), mPanels.end(), embedded_panelp));
delete embedded_panelp;
+ updateFractionalSizes();
+ mNeedsLayout = true;
}
- // need to update resizebars
-
- calcMinExtents();
-
LLView::removeChild(view);
}
@@ -221,29 +264,15 @@ bool LLLayoutStack::addChild(LLView* child, S32 tab_group)
LLLayoutPanel* panelp = dynamic_cast<LLLayoutPanel*>(child);
if (panelp)
{
- panelp->mFractionalSize = (mOrientation == HORIZONTAL)
- ? panelp->getRect().getWidth()
- : panelp->getRect().getHeight();
panelp->setOrientation(mOrientation);
mPanels.push_back(panelp);
+ createResizeBar(panelp);
+ mNeedsLayout = true;
}
- return LLView::addChild(child, tab_group);
-}
+ BOOL result = LLView::addChild(child, tab_group);
-void LLLayoutStack::movePanel(LLPanel* panel_to_move, LLPanel* target_panel, bool move_to_front)
-{
- LLLayoutPanel* embedded_panel_to_move = findEmbeddedPanel(panel_to_move);
- LLLayoutPanel* embedded_target_panel = move_to_front ? *mPanels.begin() : findEmbeddedPanel(target_panel);
-
- if (!embedded_panel_to_move || !embedded_target_panel || embedded_panel_to_move == embedded_target_panel)
- {
- llwarns << "One of the panels was not found in stack or NULL was passed instead of valid panel" << llendl;
- return;
- }
- e_panel_list_t::iterator it = std::find(mPanels.begin(), mPanels.end(), embedded_panel_to_move);
- mPanels.erase(it);
- it = move_to_front ? mPanels.begin() : std::find(mPanels.begin(), mPanels.end(), embedded_target_panel);
- mPanels.insert(it, embedded_panel_to_move);
+ updateFractionalSizes();
+ return result;
}
void LLLayoutStack::addPanel(LLLayoutPanel* panel, EAnimate animate)
@@ -258,84 +287,274 @@ void LLLayoutStack::addPanel(LLLayoutPanel* panel, EAnimate animate)
}
}
-void LLLayoutStack::removePanel(LLPanel* panel)
-{
- removeChild(panel);
-}
-
void LLLayoutStack::collapsePanel(LLPanel* panel, BOOL collapsed)
{
LLLayoutPanel* panel_container = findEmbeddedPanel(panel);
if (!panel_container) return;
panel_container->mCollapsed = collapsed;
+ mNeedsLayout = true;
}
-void LLLayoutStack::updatePanelAutoResize(const std::string& panel_name, BOOL auto_resize)
-{
- LLLayoutPanel* panel = findEmbeddedPanelByName(panel_name);
+static LLFastTimer::DeclareTimer FTM_UPDATE_LAYOUT("Update LayoutStacks");
- if (panel)
+void LLLayoutStack::updateLayout()
+{
+ LLFastTimer ft(FTM_UPDATE_LAYOUT);
+
+ if (!mNeedsLayout) return;
+
+ bool animation_in_progress = animatePanels();
+ F32 total_visible_fraction = 0.f;
+ F32 total_open_fraction = 0.f;
+ S32 space_to_distribute = (mOrientation == HORIZONTAL)
+ ? getRect().getWidth()
+ : getRect().getHeight();
+
+ // first, assign minimum dimensions
+ LLLayoutPanel* panelp = NULL;
+ BOOST_FOREACH(panelp, mPanels)
{
- panel->mAutoResize = auto_resize;
+ if (panelp->mAutoResize)
+ {
+ panelp->mTargetDim = panelp->getRelevantMinDim();
+ if (!panelp->mCollapsed && panelp->getVisible())
+ {
+ total_open_fraction += panelp->mFractionalSize;
+ }
+ }
+ space_to_distribute -= panelp->getVisibleDim() + llround((F32)mPanelSpacing * panelp->getVisibleAmount());
+ total_visible_fraction += panelp->mFractionalSize;
}
-}
-void LLLayoutStack::setPanelUserResize(const std::string& panel_name, BOOL user_resize)
+ llassert(total_visible_fraction < 1.01f);
+
+ // don't need spacing after last panel
+ space_to_distribute += panelp ? llround((F32)mPanelSpacing * panelp->getVisibleAmount()) : 0;
+
+ F32 fraction_distributed = 0.f;
+ if (space_to_distribute > 0 && total_visible_fraction > 0.f)
+ { // give space proportionally to visible auto resize panels
+ BOOST_FOREACH(LLLayoutPanel* panelp, mPanels)
+ {
+ if (panelp->mAutoResize)
+ {
+ F32 fraction_to_distribute = (panelp->mFractionalSize * panelp->getAutoResizeFactor()) / (total_visible_fraction);
+ S32 delta = llround((F32)space_to_distribute * fraction_to_distribute);
+ fraction_distributed += fraction_to_distribute;
+ panelp->mTargetDim += delta;
+ }
+ }
+ }
+
+ if (fraction_distributed < total_visible_fraction)
+ { // distribute any left over pixels to non-collapsed, visible panels
+ F32 fraction_left = total_visible_fraction - fraction_distributed;
+ S32 space_left = llround((F32)space_to_distribute * (fraction_left / total_visible_fraction));
+
+ BOOST_FOREACH(LLLayoutPanel* panelp, mPanels)
+ {
+ if (panelp->mAutoResize
+ && !panelp->mCollapsed
+ && panelp->getVisible())
+ {
+ S32 space_for_panel = llmax(0, llround((F32)space_left * (panelp->mFractionalSize / total_open_fraction)));
+ panelp->mTargetDim += space_for_panel;
+ space_left -= space_for_panel;
+ total_open_fraction -= panelp->mFractionalSize;
+ }
+ }
+ }
+
+ F32 cur_pos = (mOrientation == HORIZONTAL) ? 0.f : (F32)getRect().getHeight();
+
+ BOOST_FOREACH(LLLayoutPanel* panelp, mPanels)
+ {
+ F32 panel_dim = llmax(panelp->getExpandedMinDim(), panelp->mTargetDim);
+ F32 panel_visible_dim = panelp->getVisibleDim();
+
+ LLRect panel_rect;
+ if (mOrientation == HORIZONTAL)
+ {
+ panel_rect.setLeftTopAndSize(llround(cur_pos),
+ getRect().getHeight(),
+ llround(panel_dim),
+ getRect().getHeight());
+ }
+ else
+ {
+ panel_rect.setLeftTopAndSize(0,
+ llround(cur_pos),
+ getRect().getWidth(),
+ llround(panel_dim));
+ }
+ panelp->setIgnoreReshape(true);
+ panelp->setShape(panel_rect);
+ panelp->setIgnoreReshape(false);
+
+ LLRect resize_bar_rect(panel_rect);
+
+ F32 panel_spacing = (F32)mPanelSpacing * panelp->getVisibleAmount();
+ if (mOrientation == HORIZONTAL)
+ {
+ resize_bar_rect.mLeft = panel_rect.mRight - mResizeBarOverlap;
+ resize_bar_rect.mRight = panel_rect.mRight + (S32)(llround(panel_spacing)) + mResizeBarOverlap;
+
+ cur_pos += panel_visible_dim + panel_spacing;
+ }
+ else //VERTICAL
+ {
+ resize_bar_rect.mTop = panel_rect.mBottom + mResizeBarOverlap;
+ resize_bar_rect.mBottom = panel_rect.mBottom - (S32)(llround(panel_spacing)) - mResizeBarOverlap;
+
+ cur_pos -= panel_visible_dim + panel_spacing;
+ }
+ panelp->mResizeBar->setShape(resize_bar_rect);
+ }
+
+ updateResizeBarLimits();
+
+ // clear animation flag at end, since panel resizes will set it
+ // and leave it set if there is any animation in progress
+ mNeedsLayout = animation_in_progress;
+} // end LLLayoutStack::updateLayout
+
+LLLayoutPanel* LLLayoutStack::findEmbeddedPanel(LLPanel* panelp) const
{
- LLLayoutPanel* panel = findEmbeddedPanelByName(panel_name);
+ if (!panelp) return NULL;
- if (panel)
+ e_panel_list_t::const_iterator panel_it;
+ BOOST_FOREACH(LLLayoutPanel* p, mPanels)
{
- panel->mUserResize = user_resize;
+ if (p == panelp)
+ {
+ return p;
+ }
}
+ return NULL;
}
-bool LLLayoutStack::getPanelMinSize(const std::string& panel_name, S32* min_dimp)
+LLLayoutPanel* LLLayoutStack::findEmbeddedPanelByName(const std::string& name) const
{
- LLLayoutPanel* panel = findEmbeddedPanelByName(panel_name);
+ LLLayoutPanel* result = NULL;
- if (panel && min_dimp)
+ BOOST_FOREACH(LLLayoutPanel* p, mPanels)
{
- *min_dimp = panel->getRelevantMinDim();
+ if (p->getName() == name)
+ {
+ result = p;
+ break;
+ }
}
- return NULL != panel;
+ return result;
}
-bool LLLayoutStack::getPanelMaxSize(const std::string& panel_name, S32* max_dimp)
+void LLLayoutStack::createResizeBar(LLLayoutPanel* panelp)
{
- LLLayoutPanel* panel = findEmbeddedPanelByName(panel_name);
+ BOOST_FOREACH(LLLayoutPanel* lp, mPanels)
+ {
+ if (lp->mResizeBar == NULL)
+ {
+ LLResizeBar::Side side = (mOrientation == HORIZONTAL) ? LLResizeBar::RIGHT : LLResizeBar::BOTTOM;
+ LLRect resize_bar_rect = getRect();
- if (panel)
+ LLResizeBar::Params resize_params;
+ resize_params.name("resize");
+ resize_params.resizing_view(lp);
+ resize_params.min_size(lp->getRelevantMinDim());
+ resize_params.side(side);
+ resize_params.snapping_enabled(false);
+ LLResizeBar* resize_bar = LLUICtrlFactory::create<LLResizeBar>(resize_params);
+ lp->mResizeBar = resize_bar;
+ LLView::addChild(resize_bar, 0);
+ }
+ }
+ // bring all resize bars to the front so that they are clickable even over the panels
+ // with a bit of overlap
+ for (e_panel_list_t::iterator panel_it = mPanels.begin(); panel_it != mPanels.end(); ++panel_it)
{
- if (max_dimp) *max_dimp = panel->mMaxDim;
+ LLResizeBar* resize_barp = (*panel_it)->mResizeBar;
+ sendChildToFront(resize_barp);
}
+}
- return NULL != panel;
+// update layout stack animations, etc. once per frame
+// NOTE: we use this to size world view based on animating UI, *before* we draw the UI
+// we might still need to call updateLayout during UI draw phase, in case UI elements
+// are resizing themselves dynamically
+//static
+void LLLayoutStack::updateClass()
+{
+ for (instance_iter it = beginInstances(); it != endInstances(); ++it)
+ {
+ it->updateLayout();
+ }
}
-static LLFastTimer::DeclareTimer FTM_UPDATE_LAYOUT("Update LayoutStacks");
-void LLLayoutStack::updateLayout(BOOL force_resize)
+void LLLayoutStack::updateFractionalSizes()
{
- LLFastTimer ft(FTM_UPDATE_LAYOUT);
- static LLUICachedControl<S32> resize_bar_overlap ("UIResizeBarOverlap", 0);
- calcMinExtents();
- createResizeBars();
+ F32 total_resizable_dim = 0;
+ S32 num_auto_resize_panels = 0;
- // calculate current extents
- F32 total_size = 0.f;
+ BOOST_FOREACH(LLLayoutPanel* panelp, mPanels)
+ {
+ if (panelp->mAutoResize)
+ {
+ total_resizable_dim += llmax(0, panelp->getLayoutDim() - panelp->getRelevantMinDim());
+ num_auto_resize_panels++;
+ }
+ }
+ F32 total_fractional_size = 0.f;
+
+ BOOST_FOREACH(LLLayoutPanel* panelp, mPanels)
+ {
+ if (panelp->mAutoResize)
+ {
+ F32 panel_resizable_dim = llmax(MIN_FRACTIONAL_SIZE, (F32)(panelp->getLayoutDim() - panelp->getRelevantMinDim()));
+ panelp->mFractionalSize = panel_resizable_dim > 0.f
+ ? llclamp(panel_resizable_dim / total_resizable_dim, MIN_FRACTIONAL_SIZE, MAX_FRACTIONAL_SIZE)
+ : MIN_FRACTIONAL_SIZE;
+ total_fractional_size += panelp->mFractionalSize;
+ llassert(!llisnan(panelp->mFractionalSize));
+ }
+ }
+
+ if (total_fractional_size == 0.f)
+ { // equal distribution
+ BOOST_FOREACH(LLLayoutPanel* panelp, mPanels)
+ {
+ if (panelp->mAutoResize)
+ {
+ panelp->mFractionalSize = MAX_FRACTIONAL_SIZE / (F32)num_auto_resize_panels;
+ }
+ }
+ }
+ else
+ { // renormalize
+ BOOST_FOREACH(LLLayoutPanel* panelp, mPanels)
+ {
+ if (panelp->mAutoResize)
+ {
+ panelp->mFractionalSize /= total_fractional_size;
+ }
+ }
+ }
+}
+
+bool LLLayoutStack::animatePanels()
+{
+ bool animation_in_progress = false;
+
//
// animate visibility
//
- e_panel_list_t::iterator panel_it;
- for (panel_it = mPanels.begin(); panel_it != mPanels.end(); ++panel_it)
+ BOOST_FOREACH(LLLayoutPanel* panelp, mPanels)
{
- LLLayoutPanel* panelp = (*panel_it);
- if (panelp->getVisible())
+ if (panelp->getVisible())
{
- if (mAnimate)
+ if (mAnimate && panelp->mVisibleAmt < 1.f)
{
if (!mAnimatedThisFrame)
{
@@ -345,15 +564,21 @@ void LLLayoutStack::updateLayout(BOOL force_resize)
panelp->mVisibleAmt = 1.f;
}
}
+
+ animation_in_progress = true;
}
else
{
- panelp->mVisibleAmt = 1.f;
+ if (panelp->mVisibleAmt != 1.f)
+ {
+ panelp->mVisibleAmt = 1.f;
+ animation_in_progress = true;
+ }
}
}
else // not visible
{
- if (mAnimate)
+ if (mAnimate && panelp->mVisibleAmt > 0.f)
{
if (!mAnimatedThisFrame)
{
@@ -363,297 +588,213 @@ void LLLayoutStack::updateLayout(BOOL force_resize)
panelp->mVisibleAmt = 0.f;
}
}
+
+ animation_in_progress = true;
}
else
{
- panelp->mVisibleAmt = 0.f;
+ if (panelp->mVisibleAmt != 0.f)
+ {
+ panelp->mVisibleAmt = 0.f;
+ animation_in_progress = true;
+ }
}
}
F32 collapse_state = panelp->mCollapsed ? 1.f : 0.f;
- panelp->mCollapseAmt = lerp(panelp->mCollapseAmt, collapse_state, LLCriticalDamp::getInterpolant(mCloseTimeConstant));
-
- total_size += panelp->mFractionalSize * panelp->getCollapseFactor();
- // want n-1 panel gaps for n panels
- if (panel_it != mPanels.begin())
- {
- total_size += mPanelSpacing;
- }
- }
-
- S32 num_resizable_panels = 0;
- F32 shrink_headroom_available = 0.f;
- F32 shrink_headroom_total = 0.f;
- for (panel_it = mPanels.begin(); panel_it != mPanels.end(); ++panel_it)
- {
- LLLayoutPanel* panelp = (*panel_it);
-
- // panels that are not fully visible do not count towards shrink headroom
- if (panelp->getCollapseFactor() < 1.f)
- {
- continue;
- }
-
- F32 cur_size = panelp->mFractionalSize;
- F32 min_size = (F32)panelp->getRelevantMinDim();
-
- // if currently resizing a panel or the panel is flagged as not automatically resizing
- // only track total available headroom, but don't use it for automatic resize logic
- if (panelp->mResizeBar->hasMouseCapture()
- || (!panelp->mAutoResize
- && !force_resize))
- {
- shrink_headroom_total += cur_size - min_size;
- }
- else
- {
- num_resizable_panels++;
-
- shrink_headroom_available += cur_size - min_size;
- shrink_headroom_total += cur_size - min_size;
- }
- }
-
- // calculate how many pixels need to be distributed among layout panels
- // positive means panels need to grow, negative means shrink
- F32 pixels_to_distribute = (mOrientation == HORIZONTAL)
- ? getRect().getWidth() - total_size
- : getRect().getHeight() - total_size;
-
- // now we distribute the pixels...
- F32 cur_x = 0.f;
- F32 cur_y = (F32)getRect().getHeight();
-
- for (panel_it = mPanels.begin(); panel_it != mPanels.end(); ++panel_it)
- {
- LLLayoutPanel* panelp = (*panel_it);
-
- F32 min_size = panelp->getRelevantMinDim();
- F32 delta_size = 0.f;
-
- // if panel can automatically resize (not animating, and resize flag set)...
- if (panelp->getCollapseFactor() == 1.f
- && (force_resize || panelp->mAutoResize)
- && !panelp->mResizeBar->hasMouseCapture())
+ if (panelp->mCollapseAmt != collapse_state)
{
- if (pixels_to_distribute < 0.f)
+ if (!mAnimatedThisFrame)
{
- // shrink proportionally to amount over minimum
- // so we can do this in one pass
- delta_size = (shrink_headroom_available > 0.f)
- ? pixels_to_distribute * ((F32)(panelp->mFractionalSize - min_size) / shrink_headroom_available)
- : 0.f;
- shrink_headroom_available -= (panelp->mFractionalSize - min_size);
+ panelp->mCollapseAmt = lerp(panelp->mCollapseAmt, collapse_state, LLCriticalDamp::getInterpolant(mCloseTimeConstant));
}
- else
+ animation_in_progress = true;
+
+ if (llabs(panelp->mCollapseAmt - collapse_state) < 0.001f)
{
- // grow all elements equally
- delta_size = pixels_to_distribute / (F32)num_resizable_panels;
- num_resizable_panels--;
+ panelp->mCollapseAmt = collapse_state;
}
-
- panelp->mFractionalSize = llmax(min_size, panelp->mFractionalSize + delta_size);
- pixels_to_distribute -= delta_size;
}
+ }
- // adjust running headroom count based on new sizes
- shrink_headroom_total += delta_size;
+ mAnimatedThisFrame = true;
- LLRect panel_rect;
- if (mOrientation == HORIZONTAL)
- {
- panel_rect.setLeftTopAndSize(llround(cur_x),
- llround(cur_y),
- llround(panelp->mFractionalSize),
- getRect().getHeight());
- }
- else
- {
- panel_rect.setLeftTopAndSize(llround(cur_x),
- llround(cur_y),
- getRect().getWidth(),
- llround(panelp->mFractionalSize));
- }
- panelp->setShape(panel_rect);
+ return animation_in_progress;
+}
- LLRect resize_bar_rect = panel_rect;
- if (mOrientation == HORIZONTAL)
- {
- resize_bar_rect.mLeft = panel_rect.mRight - resize_bar_overlap;
- resize_bar_rect.mRight = panel_rect.mRight + mPanelSpacing + resize_bar_overlap;
- }
- else
- {
- resize_bar_rect.mTop = panel_rect.mBottom + resize_bar_overlap;
- resize_bar_rect.mBottom = panel_rect.mBottom - mPanelSpacing - resize_bar_overlap;
- }
- (*panel_it)->mResizeBar->setRect(resize_bar_rect);
+void LLLayoutStack::updatePanelRect( LLLayoutPanel* resized_panel, const LLRect& new_rect )
+{
+ S32 new_dim = (mOrientation == HORIZONTAL)
+ ? new_rect.getWidth()
+ : new_rect.getHeight();
+ S32 delta_dim = new_dim - resized_panel->getVisibleDim();
+ if (delta_dim == 0) return;
- F32 size = ((*panel_it)->mFractionalSize * (*panel_it)->getCollapseFactor()) + (F32)mPanelSpacing;
- if (mOrientation == HORIZONTAL)
- {
- cur_x += size;
- }
- else //VERTICAL
- {
- cur_y -= size;
- }
- }
+ F32 total_visible_fraction = 0.f;
+ F32 delta_auto_resize_headroom = 0.f;
+ F32 total_auto_resize_headroom = 0.f;
- // update resize bars with new limits
- LLLayoutPanel* last_resizeable_panel = NULL;
- for (panel_it = mPanels.begin(); panel_it != mPanels.end(); ++panel_it)
- {
- LLLayoutPanel* panelp = (*panel_it);
- S32 relevant_min = panelp->getRelevantMinDim();
+ LLLayoutPanel* other_resize_panel = NULL;
+ LLLayoutPanel* following_panel = NULL;
- if (mOrientation == HORIZONTAL)
+ BOOST_REVERSE_FOREACH(LLLayoutPanel* panelp, mPanels)
+ {
+ if (panelp->mAutoResize)
{
- (*panel_it)->mResizeBar->setResizeLimits(
- relevant_min,
- relevant_min + llround(shrink_headroom_total));
+ total_auto_resize_headroom += (F32)(panelp->mTargetDim - panelp->getRelevantMinDim());
+ total_visible_fraction += panelp->mFractionalSize * panelp->getAutoResizeFactor();
}
- else //VERTICAL
+
+ if (panelp == resized_panel)
{
- (*panel_it)->mResizeBar->setResizeLimits(
- relevant_min,
- relevant_min + llround(shrink_headroom_total));
+ other_resize_panel = following_panel;
}
- // toggle resize bars based on panel visibility, resizability, etc
- BOOL resize_bar_enabled = panelp->getVisible() && (*panel_it)->mUserResize;
- (*panel_it)->mResizeBar->setVisible(resize_bar_enabled);
-
- if ((*panel_it)->mUserResize || (*panel_it)->mAutoResize)
+ if (panelp->getVisible() && !panelp->mCollapsed)
{
- last_resizeable_panel = (*panel_it);
+ following_panel = panelp;
}
}
- // hide last resize bar as there is nothing past it
- // resize bars need to be in between two resizable panels
- if (last_resizeable_panel)
+ if (resized_panel->mAutoResize == FALSE)
{
- last_resizeable_panel->mResizeBar->setVisible(FALSE);
+ delta_auto_resize_headroom += -delta_dim;
}
-
- // not enough room to fit existing contents
- if (force_resize == FALSE
- // layout did not complete by reaching target position
- && ((mOrientation == VERTICAL && llround(cur_y) != -mPanelSpacing)
- || (mOrientation == HORIZONTAL && llround(cur_x) != getRect().getWidth() + mPanelSpacing)))
+ if (other_resize_panel && other_resize_panel->mAutoResize == FALSE)
{
- // do another layout pass with all stacked elements contributing
- // even those that don't usually resize
- llassert_always(force_resize == FALSE);
- updateLayout(TRUE);
+ delta_auto_resize_headroom += delta_dim;
}
- mAnimatedThisFrame = true;
-} // end LLLayoutStack::updateLayout
+ F32 fraction_given_up = 0.f;
+ F32 fraction_remaining = 1.f;
+ F32 updated_auto_resize_headroom = total_auto_resize_headroom + delta_auto_resize_headroom;
-
-LLLayoutPanel* LLLayoutStack::findEmbeddedPanel(LLPanel* panelp) const
-{
- if (!panelp) return NULL;
-
- e_panel_list_t::const_iterator panel_it;
- for (panel_it = mPanels.begin(); panel_it != mPanels.end(); ++panel_it)
+ enum
{
- if ((*panel_it) == panelp)
- {
- return *panel_it;
- }
- }
- return NULL;
-}
+ BEFORE_RESIZED_PANEL,
+ RESIZED_PANEL,
+ NEXT_PANEL,
+ AFTER_RESIZED_PANEL
+ } which_panel = BEFORE_RESIZED_PANEL;
-LLLayoutPanel* LLLayoutStack::findEmbeddedPanelByName(const std::string& name) const
-{
- LLLayoutPanel* result = NULL;
-
- for (e_panel_list_t::const_iterator panel_it = mPanels.begin(); panel_it != mPanels.end(); ++panel_it)
+ BOOST_FOREACH(LLLayoutPanel* panelp, mPanels)
{
- LLLayoutPanel* p = *panel_it;
+ if (!panelp->getVisible() || panelp->mCollapsed) continue;
- if (p->getName() == name)
+ if (panelp == resized_panel)
{
- result = p;
- break;
+ which_panel = RESIZED_PANEL;
}
- }
-
- return result;
-}
-
-// Compute sum of min_width or min_height of children
-void LLLayoutStack::calcMinExtents()
-{
- mMinWidth = 0;
- mMinHeight = 0;
- e_panel_list_t::iterator panel_it;
- for (panel_it = mPanels.begin(); panel_it != mPanels.end(); ++panel_it)
- {
- if (mOrientation == HORIZONTAL)
+ switch(which_panel)
{
- mMinWidth += (*panel_it)->getRelevantMinDim();
- if (panel_it != mPanels.begin())
+ case BEFORE_RESIZED_PANEL:
+ if (panelp->mAutoResize)
+ { // freeze current size as fraction of overall auto_resize space
+ F32 fractional_adjustment_factor = total_auto_resize_headroom / updated_auto_resize_headroom;
+ F32 new_fractional_size = llclamp(panelp->mFractionalSize * fractional_adjustment_factor,
+ MIN_FRACTIONAL_SIZE,
+ MAX_FRACTIONAL_SIZE);
+ F32 fraction_delta = (new_fractional_size - panelp->mFractionalSize);
+ fraction_given_up -= fraction_delta;
+ fraction_remaining -= panelp->mFractionalSize;
+ panelp->mFractionalSize += fraction_delta;
+ llassert(!llisnan(panelp->mFractionalSize));
+ }
+ else
{
- mMinWidth += mPanelSpacing;
+ // leave non auto-resize panels alone
}
- }
- else //VERTICAL
- {
- mMinHeight += (*panel_it)->getRelevantMinDim();
- if (panel_it != mPanels.begin())
+ break;
+ case RESIZED_PANEL:
+ if (panelp->mAutoResize)
+ { // freeze new size as fraction
+ F32 new_fractional_size = (updated_auto_resize_headroom == 0.f)
+ ? MAX_FRACTIONAL_SIZE
+ : llclamp((F32)(new_dim - panelp->getRelevantMinDim()) / updated_auto_resize_headroom, MIN_FRACTIONAL_SIZE, MAX_FRACTIONAL_SIZE);
+ fraction_given_up -= new_fractional_size - panelp->mFractionalSize;
+ fraction_remaining -= panelp->mFractionalSize;
+ panelp->mFractionalSize = new_fractional_size;
+ llassert(!llisnan(panelp->mFractionalSize));
+ }
+ else
+ { // freeze new size as original size
+ panelp->mTargetDim = new_dim;
+ fraction_remaining -= fraction_given_up;
+ }
+ which_panel = NEXT_PANEL;
+ break;
+ case NEXT_PANEL:
+ if (panelp->mAutoResize)
+ {
+ fraction_remaining -= panelp->mFractionalSize;
+ if (fraction_given_up != 0.f)
+ {
+ panelp->mFractionalSize = llclamp(panelp->mFractionalSize + fraction_given_up, MIN_FRACTIONAL_SIZE, MAX_FRACTIONAL_SIZE);
+ fraction_given_up = 0.f;
+ }
+ else
+ {
+ F32 new_fractional_size = llclamp((F32)(panelp->mTargetDim - panelp->getRelevantMinDim() + delta_auto_resize_headroom)
+ / updated_auto_resize_headroom,
+ MIN_FRACTIONAL_SIZE,
+ MAX_FRACTIONAL_SIZE);
+ fraction_given_up -= new_fractional_size - panelp->mFractionalSize;
+ panelp->mFractionalSize = new_fractional_size;
+ }
+ }
+ else
+ {
+ panelp->mTargetDim -= delta_dim;
+ }
+ which_panel = AFTER_RESIZED_PANEL;
+ break;
+ case AFTER_RESIZED_PANEL:
+ if (panelp->mAutoResize)
{
- mMinHeight += mPanelSpacing;
+ panelp->mFractionalSize = llclamp(panelp->mFractionalSize + (panelp->mFractionalSize / fraction_remaining) * fraction_given_up,
+ MIN_FRACTIONAL_SIZE,
+ MAX_FRACTIONAL_SIZE);
}
+ default:
+ break;
}
}
}
-void LLLayoutStack::createResizeBars()
+void LLLayoutStack::reshape(S32 width, S32 height, BOOL called_from_parent)
{
- for (e_panel_list_t::iterator panel_it = mPanels.begin(); panel_it != mPanels.end(); ++panel_it)
+ mNeedsLayout = true;
+ LLView::reshape(width, height, called_from_parent);
+}
+
+void LLLayoutStack::updateResizeBarLimits()
+{
+ LLLayoutPanel* previous_visible_panelp = NULL;
+ BOOST_REVERSE_FOREACH(LLLayoutPanel* visible_panelp, mPanels)
{
- LLLayoutPanel* lp = (*panel_it);
- if (lp->mResizeBar == NULL)
+ if (!visible_panelp->getVisible() || visible_panelp->mCollapsed)
{
- LLResizeBar::Side side = (mOrientation == HORIZONTAL) ? LLResizeBar::RIGHT : LLResizeBar::BOTTOM;
- LLRect resize_bar_rect = getRect();
-
- LLResizeBar::Params resize_params;
- resize_params.name("resize");
- resize_params.resizing_view(lp);
- resize_params.min_size(lp->getRelevantMinDim());
- resize_params.side(side);
- resize_params.snapping_enabled(false);
- LLResizeBar* resize_bar = LLUICtrlFactory::create<LLResizeBar>(resize_params);
- lp->mResizeBar = resize_bar;
- LLView::addChild(resize_bar, 0);
+ visible_panelp->mResizeBar->setVisible(FALSE);
+ continue;
+ }
- // bring all resize bars to the front so that they are clickable even over the panels
- // with a bit of overlap
- for (e_panel_list_t::iterator panel_it = mPanels.begin(); panel_it != mPanels.end(); ++panel_it)
- {
- LLResizeBar* resize_barp = (*panel_it)->mResizeBar;
- sendChildToFront(resize_barp);
- }
+ // toggle resize bars based on panel visibility, resizability, etc
+ if (previous_visible_panelp
+ && (visible_panelp->mUserResize || previous_visible_panelp->mUserResize) // one of the pair is user resizable
+ && (visible_panelp->mAutoResize || visible_panelp->mUserResize) // current panel is resizable
+ && (previous_visible_panelp->mAutoResize || previous_visible_panelp->mUserResize)) // previous panel is resizable
+ {
+ visible_panelp->mResizeBar->setVisible(TRUE);
+ S32 previous_panel_headroom = previous_visible_panelp->getVisibleDim() - previous_visible_panelp->getRelevantMinDim();
+ visible_panelp->mResizeBar->setResizeLimits(visible_panelp->getRelevantMinDim(),
+ visible_panelp->getVisibleDim() + previous_panel_headroom);
+ }
+ else
+ {
+ visible_panelp->mResizeBar->setVisible(FALSE);
}
- }
-}
-// update layout stack animations, etc. once per frame
-// NOTE: we use this to size world view based on animating UI, *before* we draw the UI
-// we might still need to call updateLayout during UI draw phase, in case UI elements
-// are resizing themselves dynamically
-//static
-void LLLayoutStack::updateClass()
-{
- for (instance_iter it = beginInstances(); it != endInstances(); ++it)
- {
- it->updateLayout();
+ previous_visible_panelp = visible_panelp;
}
}
diff --git a/indra/llui/lllayoutstack.h b/indra/llui/lllayoutstack.h
index ede6149a80..efe93f6def 100644
--- a/indra/llui/lllayoutstack.h
+++ b/indra/llui/lllayoutstack.h
@@ -5,7 +5,7 @@
*
* $LicenseInfo:firstyear=2001&license=viewerlgpl$
* Second Life Viewer Source Code
- * Copyright (C) 2010, Linden Research, Inc.
+ * Copyright (C) 2010, Linden Reshasearch, Inc.
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
@@ -60,6 +60,7 @@ public:
clip;
Optional<F32> open_time_constant,
close_time_constant;
+ Optional<S32> resize_bar_overlap;
Params();
};
@@ -72,12 +73,11 @@ public:
/*virtual*/ void removeChild(LLView*);
/*virtual*/ BOOL postBuild();
/*virtual*/ bool addChild(LLView* child, S32 tab_group = 0);
+ /*virtual*/ void reshape(S32 width, S32 height, BOOL called_from_parent = TRUE);
+
static LLView* fromXML(LLXMLNodePtr node, LLView *parent, LLXMLNodePtr output_node = NULL);
- S32 getMinWidth() const { return mMinWidth; }
- S32 getMinHeight() const { return mMinHeight; }
-
typedef enum e_animate
{
NO_ANIMATE,
@@ -85,47 +85,24 @@ public:
} EAnimate;
void addPanel(LLLayoutPanel* panel, EAnimate animate = NO_ANIMATE);
- void removePanel(LLPanel* panel);
void collapsePanel(LLPanel* panel, BOOL collapsed = TRUE);
S32 getNumPanels() { return mPanels.size(); }
- /**
- * Moves panel_to_move before target_panel inside layout stack (both panels should already be there).
- * If move_to_front is true target_panel is ignored and panel_to_move is moved to the beginning of mPanels
- */
- void movePanel(LLPanel* panel_to_move, LLPanel* target_panel, bool move_to_front = false);
-
- void updatePanelAutoResize(const std::string& panel_name, BOOL auto_resize);
- void setPanelUserResize(const std::string& panel_name, BOOL user_resize);
-
- /**
- * Gets minimal dimension along layout_stack axis of the specified by name panel.
- *
- * @returns true if specified by panel_name internal panel exists, false otherwise.
- */
- bool getPanelMinSize(const std::string& panel_name, S32* min_dimp);
-
- /**
- * Gets maximal dimension along layout_stack axis of the specified by name panel.
- *
- * @returns true if specified by panel_name internal panel exists, false otherwise.
- */
- bool getPanelMaxSize(const std::string& panel_name, S32* max_dim);
-
- void updateLayout(BOOL force_resize = FALSE);
-
+
+ void updateLayout();
+
S32 getPanelSpacing() const { return mPanelSpacing; }
- BOOL getAnimate () const { return mAnimate; }
- void setAnimate (BOOL animate) { mAnimate = animate; }
static void updateClass();
protected:
LLLayoutStack(const Params&);
friend class LLUICtrlFactory;
+ friend class LLLayoutPanel;
private:
- void createResizeBars();
- void calcMinExtents();
+ void updateResizeBarLimits();
+ bool animatePanels();
+ void createResizeBar(LLLayoutPanel* panel);
const ELayoutOrientation mOrientation;
@@ -134,17 +111,19 @@ private:
LLLayoutPanel* findEmbeddedPanel(LLPanel* panelp) const;
LLLayoutPanel* findEmbeddedPanelByName(const std::string& name) const;
+ void updateFractionalSizes();
+ void updatePanelRect( LLLayoutPanel* param1, const LLRect& new_rect );
- S32 mMinWidth; // calculated by calcMinExtents
- S32 mMinHeight; // calculated by calcMinExtents
S32 mPanelSpacing;
// true if we already applied animation this frame
bool mAnimatedThisFrame;
bool mAnimate;
bool mClip;
- F32 mOpenTimeConstant;
- F32 mCloseTimeConstant;
+ F32 mOpenTimeConstant;
+ F32 mCloseTimeConstant;
+ bool mNeedsLayout;
+ S32 mResizeBarOverlap;
}; // end class LLLayoutStack
@@ -156,8 +135,7 @@ public:
struct Params : public LLInitParam::Block<Params, LLPanel::Params>
{
Optional<S32> expanded_min_dim,
- min_dim,
- max_dim;
+ min_dim;
Optional<bool> user_resize,
auto_resize;
@@ -168,16 +146,19 @@ public:
void initFromParams(const Params& p);
+ void handleReshape(const LLRect& new_rect, bool by_user);
+
void reshape(S32 width, S32 height, BOOL called_from_parent = TRUE);
+
- S32 getMinDim() const { return mMinDim; }
- void setMinDim(S32 value) { mMinDim = value; if (!mExpandedMinDimSpecified) mExpandedMinDim = value; }
+ void setVisible(BOOL visible);
- S32 getMaxDim() const { return mMaxDim; }
- void setMaxDim(S32 value) { mMaxDim = value; }
+ S32 getLayoutDim() const;
+ S32 getMinDim() const { return (mMinDim >= 0 || mAutoResize) ? llmax(0, mMinDim) : getLayoutDim(); }
+ void setMinDim(S32 value) { mMinDim = value; }
- S32 getExpandedMinDim() const { return mExpandedMinDim; }
- void setExpandedMinDim(S32 value) { mExpandedMinDim = value; mExpandedMinDimSpecified = true; }
+ S32 getExpandedMinDim() const { return mExpandedMinDim >= 0 ? mExpandedMinDim : mMinDim; }
+ void setExpandedMinDim(S32 value) { mExpandedMinDim = value; }
S32 getRelevantMinDim() const
{
@@ -185,30 +166,35 @@ public:
if (!mCollapsed)
{
- min_dim = mExpandedMinDim;
+ min_dim = getExpandedMinDim();
}
return min_dim;
}
- void setOrientation(LLLayoutStack::ELayoutOrientation orientation) { mOrientation = orientation; }
+ F32 getAutoResizeFactor() const;
+ F32 getVisibleAmount() const;
+ S32 getVisibleDim() const;
+
+ void setOrientation(LLLayoutStack::ELayoutOrientation orientation);
+ void storeOriginalDim();
+
+ void setIgnoreReshape(bool ignore) { mIgnoreReshape = ignore; }
protected:
LLLayoutPanel(const Params& p);
- F32 getCollapseFactor();
+ const bool mAutoResize;
+ const bool mUserResize;
- bool mExpandedMinDimSpecified;
S32 mExpandedMinDim;
-
S32 mMinDim;
- S32 mMaxDim;
- bool mAutoResize;
- bool mUserResize;
bool mCollapsed;
F32 mVisibleAmt;
F32 mCollapseAmt;
F32 mFractionalSize;
+ S32 mTargetDim;
+ bool mIgnoreReshape;
LLLayoutStack::ELayoutOrientation mOrientation;
class LLResizeBar* mResizeBar;
};
diff --git a/indra/llui/llmenugl.cpp b/indra/llui/llmenugl.cpp
index cb237fca7c..95ecbb1c94 100644
--- a/indra/llui/llmenugl.cpp
+++ b/indra/llui/llmenugl.cpp
@@ -947,9 +947,14 @@ LLMenuItemBranchGL::LLMenuItemBranchGL(const LLMenuItemBranchGL::Params& p)
LLMenuItemBranchGL::~LLMenuItemBranchGL()
{
- delete mBranchHandle.get();
+ if (mBranchHandle.get())
+ {
+ mBranchHandle.get()->die();
+ }
}
+
+
// virtual
LLView* LLMenuItemBranchGL::getChildView(const std::string& name, BOOL recurse) const
{
diff --git a/indra/llui/llpanel.h b/indra/llui/llpanel.h
index cd33938226..f620201020 100644
--- a/indra/llui/llpanel.h
+++ b/indra/llui/llpanel.h
@@ -135,6 +135,8 @@ public:
const LLColor4& getBackgroundColor() const { return mBgOpaqueColor; }
void setTransparentColor(const LLColor4& color) { mBgAlphaColor = color; }
const LLColor4& getTransparentColor() const { return mBgAlphaColor; }
+ void setBackgroundImage(LLUIImage* image) { mBgOpaqueImage = image; }
+ void setTransparentImage(LLUIImage* image) { mBgAlphaImage = image; }
LLPointer<LLUIImage> getBackgroundImage() const { return mBgOpaqueImage; }
LLPointer<LLUIImage> getTransparentImage() const { return mBgAlphaImage; }
LLColor4 getBackgroundImageOverlay() { return mBgOpaqueImageOverlay; }
diff --git a/indra/llui/llresizebar.cpp b/indra/llui/llresizebar.cpp
index 02f60c76fa..87aeb4d7a7 100644
--- a/indra/llui/llresizebar.cpp
+++ b/indra/llui/llresizebar.cpp
@@ -79,6 +79,8 @@ LLResizeBar::LLResizeBar(const LLResizeBar::Params& p)
BOOL LLResizeBar::handleMouseDown(S32 x, S32 y, MASK mask)
{
+ if (!canResize()) return FALSE;
+
// Route future Mouse messages here preemptively. (Release on mouse up.)
// No handler needed for focus lost since this clas has no state that depends on it.
gFocusMgr.setMouseCapture( this );
@@ -243,7 +245,7 @@ BOOL LLResizeBar::handleHover(S32 x, S32 y, MASK mask)
handled = TRUE;
}
- if( handled )
+ if( handled && canResize() )
{
switch( mSide )
{
diff --git a/indra/llui/llresizebar.h b/indra/llui/llresizebar.h
index 0725fbd846..6daf191918 100644
--- a/indra/llui/llresizebar.h
+++ b/indra/llui/llresizebar.h
@@ -70,6 +70,7 @@ public:
void setResizeLimits( S32 min_size, S32 max_size ) { mMinSize = min_size; mMaxSize = max_size; }
void setEnableSnapping(BOOL enable) { mSnappingEnabled = enable; }
void setAllowDoubleClickSnapping(BOOL allow) { mAllowDoubleClickSnapping = allow; }
+ bool canResize() { return getEnabled() && mMaxSize > mMinSize; }
private:
S32 mDragLastScreenX;
diff --git a/indra/llui/llscrollcontainer.cpp b/indra/llui/llscrollcontainer.cpp
index fe3f688fc5..ad4cc20d9a 100644
--- a/indra/llui/llscrollcontainer.cpp
+++ b/indra/llui/llscrollcontainer.cpp
@@ -424,63 +424,66 @@ void LLScrollContainer::draw()
focusFirstItem();
}
- // Draw background
- if( mIsOpaque )
+ if (getRect().isValid())
{
- F32 alpha = getCurrentTransparency();
+ // Draw background
+ if( mIsOpaque )
+ {
+ F32 alpha = getCurrentTransparency();
- gGL.getTexUnit(0)->unbind(LLTexUnit::TT_TEXTURE);
- gl_rect_2d(mInnerRect, mBackgroundColor.get() % alpha);
- }
+ gGL.getTexUnit(0)->unbind(LLTexUnit::TT_TEXTURE);
+ gl_rect_2d(mInnerRect, mBackgroundColor.get() % alpha);
+ }
- // Draw mScrolledViews and update scroll bars.
- // get a scissor region ready, and draw the scrolling view. The
- // scissor region ensures that we don't draw outside of the bounds
- // of the rectangle.
- if( mScrolledView )
- {
- updateScroll();
-
- // Draw the scrolled area.
+ // Draw mScrolledViews and update scroll bars.
+ // get a scissor region ready, and draw the scrolling view. The
+ // scissor region ensures that we don't draw outside of the bounds
+ // of the rectangle.
+ if( mScrolledView )
{
- S32 visible_width = 0;
- S32 visible_height = 0;
- BOOL show_v_scrollbar = FALSE;
- BOOL show_h_scrollbar = FALSE;
- calcVisibleSize( &visible_width, &visible_height, &show_h_scrollbar, &show_v_scrollbar );
-
- LLLocalClipRect clip(LLRect(mInnerRect.mLeft,
- mInnerRect.mBottom + (show_h_scrollbar ? scrollbar_size : 0) + visible_height,
- mInnerRect.mRight - (show_v_scrollbar ? scrollbar_size: 0),
- mInnerRect.mBottom + (show_h_scrollbar ? scrollbar_size : 0)
- ));
- drawChild(mScrolledView);
- }
- }
-
- // Highlight border if a child of this container has keyboard focus
- if( mBorder->getVisible() )
- {
- mBorder->setKeyboardFocusHighlight( gFocusMgr.childHasKeyboardFocus(this) );
- }
+ updateScroll();
- // Draw all children except mScrolledView
- // Note: scrollbars have been adjusted by above drawing code
- for (child_list_const_reverse_iter_t child_iter = getChildList()->rbegin();
- child_iter != getChildList()->rend(); ++child_iter)
- {
- LLView *viewp = *child_iter;
- if( sDebugRects )
- {
- sDepth++;
+ // Draw the scrolled area.
+ {
+ S32 visible_width = 0;
+ S32 visible_height = 0;
+ BOOL show_v_scrollbar = FALSE;
+ BOOL show_h_scrollbar = FALSE;
+ calcVisibleSize( &visible_width, &visible_height, &show_h_scrollbar, &show_v_scrollbar );
+
+ LLLocalClipRect clip(LLRect(mInnerRect.mLeft,
+ mInnerRect.mBottom + (show_h_scrollbar ? scrollbar_size : 0) + visible_height,
+ mInnerRect.mRight - (show_v_scrollbar ? scrollbar_size: 0),
+ mInnerRect.mBottom + (show_h_scrollbar ? scrollbar_size : 0)
+ ));
+ drawChild(mScrolledView);
+ }
}
- if( (viewp != mScrolledView) && viewp->getVisible() )
+
+ // Highlight border if a child of this container has keyboard focus
+ if( mBorder->getVisible() )
{
- drawChild(viewp);
+ mBorder->setKeyboardFocusHighlight( gFocusMgr.childHasKeyboardFocus(this) );
}
- if( sDebugRects )
+
+ // Draw all children except mScrolledView
+ // Note: scrollbars have been adjusted by above drawing code
+ for (child_list_const_reverse_iter_t child_iter = getChildList()->rbegin();
+ child_iter != getChildList()->rend(); ++child_iter)
{
- sDepth--;
+ LLView *viewp = *child_iter;
+ if( sDebugRects )
+ {
+ sDepth++;
+ }
+ if( (viewp != mScrolledView) && viewp->getVisible() )
+ {
+ drawChild(viewp);
+ }
+ if( sDebugRects )
+ {
+ sDepth--;
+ }
}
}
} // end draw
diff --git a/indra/llui/lltabcontainer.cpp b/indra/llui/lltabcontainer.cpp
index d5f8707381..5fc2cc350d 100644
--- a/indra/llui/lltabcontainer.cpp
+++ b/indra/llui/lltabcontainer.cpp
@@ -98,24 +98,25 @@ class LLCustomButtonIconCtrl : public LLButton
{
public:
struct Params
- : public LLInitParam::Block<Params, LLButton::Params>
+ : public LLInitParam::Block<Params, LLButton::Params>
{
// LEFT, RIGHT, TOP, BOTTOM paddings of LLIconCtrl in this class has same value
Optional<S32> icon_ctrl_pad;
- Params():
- icon_ctrl_pad("icon_ctrl_pad", 1)
+ Params()
+ : icon_ctrl_pad("icon_ctrl_pad", 1)
{}
};
protected:
friend class LLUICtrlFactory;
- LLCustomButtonIconCtrl(const Params& p):
- LLButton(p),
+
+ LLCustomButtonIconCtrl(const Params& p)
+ : LLButton(p),
mIcon(NULL),
mIconAlignment(LLFontGL::HCENTER),
mIconCtrlPad(p.icon_ctrl_pad)
- {}
+ {}
public:
diff --git a/indra/llui/lltextbase.cpp b/indra/llui/lltextbase.cpp
index 3b768166f1..0040be45c7 100644
--- a/indra/llui/lltextbase.cpp
+++ b/indra/llui/lltextbase.cpp
@@ -598,7 +598,7 @@ S32 LLTextBase::insertStringNoUndo(S32 pos, const LLWString &wstr, LLTextBase::s
pos = getEditableIndex(pos, true);
- segment_set_t::iterator seg_iter = getSegIterContaining(pos);
+ segment_set_t::iterator seg_iter = getEditableSegIterContaining(pos);
LLTextSegmentPtr default_segment;
@@ -1510,8 +1510,48 @@ void LLTextBase::getSegmentAndOffset( S32 startpos, segment_set_t::iterator* seg
}
}
+LLTextBase::segment_set_t::iterator LLTextBase::getEditableSegIterContaining(S32 index)
+{
+ segment_set_t::iterator it = getSegIterContaining(index);
+ segment_set_t::iterator orig_it = it;
+
+ if (it == mSegments.end()) return it;
+
+ if (!(*it)->canEdit()
+ && index == (*it)->getStart()
+ && it != mSegments.begin())
+ {
+ it--;
+ if ((*it)->canEdit())
+ {
+ return it;
+ }
+ }
+ return orig_it;
+}
+
+LLTextBase::segment_set_t::const_iterator LLTextBase::getEditableSegIterContaining(S32 index) const
+{
+ segment_set_t::const_iterator it = getSegIterContaining(index);
+ segment_set_t::const_iterator orig_it = it;
+ if (it == mSegments.end()) return it;
+
+ if (!(*it)->canEdit()
+ && index == (*it)->getStart()
+ && it != mSegments.begin())
+ {
+ it--;
+ if ((*it)->canEdit())
+ {
+ return it;
+ }
+ }
+ return orig_it;
+}
+
LLTextBase::segment_set_t::iterator LLTextBase::getSegIterContaining(S32 index)
{
+
static LLPointer<LLIndexSegment> index_segment = new LLIndexSegment();
if (index > getLength()) { return mSegments.end(); }
diff --git a/indra/llui/lltextbase.h b/indra/llui/lltextbase.h
index b699601908..0549141b72 100644
--- a/indra/llui/lltextbase.h
+++ b/indra/llui/lltextbase.h
@@ -461,6 +461,8 @@ protected:
void getSegmentAndOffset( S32 startpos, segment_set_t::const_iterator* seg_iter, S32* offsetp ) const;
void getSegmentAndOffset( S32 startpos, segment_set_t::iterator* seg_iter, S32* offsetp );
LLTextSegmentPtr getSegmentAtLocalPos( S32 x, S32 y, bool hit_past_end_of_line = true);
+ segment_set_t::iterator getEditableSegIterContaining(S32 index);
+ segment_set_t::const_iterator getEditableSegIterContaining(S32 index) const;
segment_set_t::iterator getSegIterContaining(S32 index);
segment_set_t::const_iterator getSegIterContaining(S32 index) const;
void clearSegments();
diff --git a/indra/llui/lltexteditor.cpp b/indra/llui/lltexteditor.cpp
index 9bd445988d..3a23ce1cac 100644
--- a/indra/llui/lltexteditor.cpp
+++ b/indra/llui/lltexteditor.cpp
@@ -2250,6 +2250,22 @@ void LLTextEditor::insertText(const std::string &new_text)
setEnabled( enabled );
}
+void LLTextEditor::insertText(LLWString &new_text)
+{
+ BOOL enabled = getEnabled();
+ setEnabled( TRUE );
+
+ // Delete any selected characters (the insertion replaces them)
+ if( hasSelection() )
+ {
+ deleteSelection(TRUE);
+ }
+
+ setCursorPos(mCursorPos + insert( mCursorPos, new_text, FALSE, LLTextSegmentPtr() ));
+
+ setEnabled( enabled );
+}
+
void LLTextEditor::appendWidget(const LLInlineViewSegment::Params& params, const std::string& text, bool allow_undo)
{
// Save old state
@@ -2838,3 +2854,13 @@ void LLTextEditor::clear()
getViewModel()->setDisplay(LLWStringUtil::null);
clearSegments();
}
+
+bool LLTextEditor::canLoadOrSaveToFile()
+{
+ return !mReadOnly;
+}
+
+S32 LLTextEditor::spacesPerTab()
+{
+ return SPACES_PER_TAB;
+}
diff --git a/indra/llui/lltexteditor.h b/indra/llui/lltexteditor.h
index 9e4b95003b..40821ae9fb 100644
--- a/indra/llui/lltexteditor.h
+++ b/indra/llui/lltexteditor.h
@@ -92,6 +92,8 @@ public:
void setParseHighlights(BOOL parsing) {mParseHighlights=parsing;}
+ static S32 spacesPerTab();
+
// mousehandler overrides
virtual BOOL handleMouseDown(S32 x, S32 y, MASK mask);
virtual BOOL handleMouseUp(S32 x, S32 y, MASK mask);
@@ -140,6 +142,8 @@ public:
virtual void selectAll();
virtual BOOL canSelectAll() const;
+ virtual bool canLoadOrSaveToFile();
+
void selectNext(const std::string& search_text_in, BOOL case_insensitive, BOOL wrap = TRUE);
BOOL replaceText(const std::string& search_text, const std::string& replace_text, BOOL case_insensitive, BOOL wrap = TRUE);
void replaceTextAll(const std::string& search_text, const std::string& replace_text, BOOL case_insensitive);
@@ -158,6 +162,7 @@ public:
// inserts text at cursor
void insertText(const std::string &text);
+ void insertText(LLWString &text);
void appendWidget(const LLInlineViewSegment::Params& params, const std::string& text, bool allow_undo);
// Non-undoable
diff --git a/indra/llui/lltoolbar.cpp b/indra/llui/lltoolbar.cpp
index 7f96c1373c..9b31a6449d 100644
--- a/indra/llui/lltoolbar.cpp
+++ b/indra/llui/lltoolbar.cpp
@@ -151,14 +151,20 @@ void LLToolBar::createContextMenu()
if (menu)
{
menu->setBackgroundColor(LLUIColorTable::instance().getColor("MenuPopupBgColor"));
-
mPopupMenuHandle = menu->getHandle();
+ mRemoveButtonHandle = menu->getChild<LLView>("Remove button")->getHandle();
}
else
{
llwarns << "Unable to load toolbars context menu." << llendl;
}
}
+
+ if (mRemoveButtonHandle.get())
+ {
+ // Disable/Enable the "Remove button" menu item depending on whether or not a button was clicked
+ mRemoveButtonHandle.get()->setEnabled(mRightMouseTargetButton != NULL);
+ }
}
void LLToolBar::initFromParams(const LLToolBar::Params& p)
@@ -401,6 +407,7 @@ BOOL LLToolBar::handleRightMouseDown(S32 x, S32 y, MASK mask)
{
// Determine which button the mouse was over during the click in case the context menu action
// is intended to affect the button.
+ mRightMouseTargetButton = NULL;
BOOST_FOREACH(LLToolBarButton* button, mButtons)
{
LLRect button_rect;
diff --git a/indra/llui/lltoolbar.h b/indra/llui/lltoolbar.h
index 51fe23ddd1..a50c60282c 100644
--- a/indra/llui/lltoolbar.h
+++ b/indra/llui/lltoolbar.h
@@ -271,6 +271,7 @@ private:
LLLayoutStack* mCenteringStack;
LLPanel* mButtonPanel;
LLHandle<class LLContextMenu> mPopupMenuHandle;
+ LLHandle<class LLView> mRemoveButtonHandle;
LLToolBarButton* mRightMouseTargetButton;
diff --git a/indra/llui/llview.cpp b/indra/llui/llview.cpp
index 486babb0ab..e1ee0a5b14 100644
--- a/indra/llui/llview.cpp
+++ b/indra/llui/llview.cpp
@@ -121,6 +121,7 @@ LLView::Params::Params()
LLView::LLView(const LLView::Params& p)
: mVisible(p.visible),
+ mInDraw(false),
mName(p.name),
mParentView(NULL),
mReshapeFlags(FOLLOWS_NONE),
@@ -333,6 +334,8 @@ void LLView::removeChild(LLView* child)
//llassert_always(sDepth == 0); // Avoid re-ordering while drawing; it can cause subtle iterator bugs
if (child->mParentView == this)
{
+ // if we are removing an item we are currently iterating over, that would be bad
+ llassert(child->mInDraw == false);
mChildList.remove( child );
child->mParentView = NULL;
if (child->isCtrl())
@@ -1090,6 +1093,11 @@ void LLView::drawChildren()
{
child_list_reverse_iter_t child = child_iter++;
LLView *viewp = *child;
+
+ if (viewp == NULL)
+ {
+ continue;
+ }
if (viewp->getVisible() && viewp->getRect().isValid())
{
@@ -1099,7 +1107,10 @@ void LLView::drawChildren()
LLUI::pushMatrix();
{
LLUI::translate((F32)viewp->getRect().mLeft, (F32)viewp->getRect().mBottom, 0.f);
+ // flag the fact we are in draw here, in case overridden draw() method attempts to remove this widget
+ viewp->mInDraw = true;
viewp->draw();
+ viewp->mInDraw = false;
if (sDebugRects)
{
diff --git a/indra/llui/llview.h b/indra/llui/llview.h
index f21fb37e18..f1fac5f69c 100644
--- a/indra/llui/llview.h
+++ b/indra/llui/llview.h
@@ -612,6 +612,8 @@ private:
S32 mNextInsertionOrdinal;
+ bool mInDraw;
+
static LLWindow* sWindow; // All root views must know about their window.
typedef std::map<std::string, LLView*> default_widget_map_t;
diff --git a/indra/llui/llwindowshade.cpp b/indra/llui/llwindowshade.cpp
index cf76202215..f5c463c961 100644
--- a/indra/llui/llwindowshade.cpp
+++ b/indra/llui/llwindowshade.cpp
@@ -37,10 +37,13 @@
const S32 MIN_NOTIFICATION_AREA_HEIGHT = 30;
const S32 MAX_NOTIFICATION_AREA_HEIGHT = 100;
+static LLDefaultChildRegistry::Register<LLWindowShade> r("window_shade");
+
LLWindowShade::Params::Params()
: bg_image("bg_image"),
modal("modal", false),
text_color("text_color"),
+ shade_color("shade_color"),
can_close("can_close", true)
{
changeDefault(mouse_opaque, false);
@@ -48,7 +51,6 @@ LLWindowShade::Params::Params()
LLWindowShade::LLWindowShade(const LLWindowShade::Params& params)
: LLUICtrl(params),
- mNotification(params.notification),
mModal(params.modal),
mFormHeight(0),
mTextColor(params.text_color)
@@ -72,7 +74,7 @@ void LLWindowShade::initFromParams(const LLWindowShade::Params& params)
addChild(stackp);
LLLayoutPanel::Params panel_p;
- panel_p.rect = LLRect(0, 30, 800, 0);
+ panel_p.rect = LLRect(0, MIN_NOTIFICATION_AREA_HEIGHT, 800, 0);
panel_p.name = "notification_area";
panel_p.visible = false;
panel_p.user_resize = false;
@@ -89,7 +91,7 @@ void LLWindowShade::initFromParams(const LLWindowShade::Params& params)
panel_p.name = "background_area";
panel_p.mouse_opaque = false;
panel_p.background_visible = false;
- panel_p.bg_alpha_color = LLColor4(0.f, 0.f, 0.f, 0.2f);
+ panel_p.bg_alpha_color = params.shade_color;
LLLayoutPanel* dummy_panel = LLUICtrlFactory::create<LLLayoutPanel>(panel_p);
stackp->addChild(dummy_panel);
@@ -107,11 +109,11 @@ void LLWindowShade::initFromParams(const LLWindowShade::Params& params)
LLIconCtrl::Params icon_p;
icon_p.name = "notification_icon";
- icon_p.rect = LLRect(5, 23, 21, 8);
+ icon_p.rect = LLRect(5, 25, 21, 10);
panel->addChild(LLUICtrlFactory::create<LLIconCtrl>(icon_p));
LLTextBox::Params text_p;
- text_p.rect = LLRect(31, 20, panel->getRect().getWidth() - 5, 0);
+ text_p.rect = LLRect(31, 23, panel->getRect().getWidth() - 5, 3);
text_p.follows.flags = FOLLOWS_ALL;
text_p.text_color = mTextColor;
text_p.font = LLFontGL::getFontSansSerifSmall();
@@ -125,41 +127,132 @@ void LLWindowShade::initFromParams(const LLWindowShade::Params& params)
panel_p.auto_resize = false;
panel_p.user_resize = false;
panel_p.name="form_elements";
- panel_p.rect = LLRect(0, 30, 130, 0);
+ panel_p.rect = LLRect(0, MIN_NOTIFICATION_AREA_HEIGHT, 130, 0);
LLLayoutPanel* form_elements_panel = LLUICtrlFactory::create<LLLayoutPanel>(panel_p);
stackp->addChild(form_elements_panel);
- if (params.can_close)
+ panel_p = LLUICtrlFactory::getDefaultParams<LLLayoutPanel>();
+ panel_p.auto_resize = false;
+ panel_p.user_resize = false;
+ panel_p.rect = LLRect(0, MIN_NOTIFICATION_AREA_HEIGHT, 25, 0);
+ panel_p.name = "close_panel";
+ LLLayoutPanel* close_panel = LLUICtrlFactory::create<LLLayoutPanel>(panel_p);
+ stackp->addChild(close_panel);
+
+ LLButton::Params button_p;
+ button_p.name = "close_notification";
+ button_p.rect = LLRect(5, 23, 21, 7);
+ button_p.image_color.control="DkGray_66";
+ button_p.image_unselected.name="Icon_Close_Foreground";
+ button_p.image_selected.name="Icon_Close_Press";
+ button_p.click_callback.function = boost::bind(&LLWindowShade::onCloseNotification, this);
+
+ close_panel->addChild(LLUICtrlFactory::create<LLButton>(button_p));
+
+ close_panel->setVisible(params.can_close);
+}
+
+void LLWindowShade::draw()
+{
+ LLRect message_rect = getChild<LLTextBox>("notification_text")->getTextBoundingRect();
+
+ LLLayoutPanel* notification_area = getChild<LLLayoutPanel>("notification_area");
+
+ notification_area->reshape(notification_area->getRect().getWidth(),
+ llclamp(message_rect.getHeight() + 15,
+ llmax(mFormHeight, MIN_NOTIFICATION_AREA_HEIGHT),
+ MAX_NOTIFICATION_AREA_HEIGHT));
+
+ LLUICtrl::draw();
+
+ while(!mNotifications.empty() && !mNotifications.back()->isActive())
+ {
+ mNotifications.pop_back();
+ // go ahead and hide
+ hide();
+ }
+
+ if (mNotifications.empty())
+ {
+ hide();
+ }
+ else if (notification_area->getVisibleAmount() < 0.01f)
+ {
+ displayLatestNotification();
+ }
+
+ if (!notification_area->getVisible() && (notification_area->getVisibleAmount() < 0.001f))
{
- panel_p = LLUICtrlFactory::getDefaultParams<LLLayoutPanel>();
- panel_p.auto_resize = false;
- panel_p.user_resize = false;
- panel_p.rect = LLRect(0, 30, 25, 0);
- LLLayoutPanel* close_panel = LLUICtrlFactory::create<LLLayoutPanel>(panel_p);
- stackp->addChild(close_panel);
-
- LLButton::Params button_p;
- button_p.name = "close_notification";
- button_p.rect = LLRect(5, 23, 21, 7);
- button_p.image_color.control="DkGray_66";
- button_p.image_unselected.name="Icon_Close_Foreground";
- button_p.image_selected.name="Icon_Close_Press";
- button_p.click_callback.function = boost::bind(&LLWindowShade::onCloseNotification, this);
-
- close_panel->addChild(LLUICtrlFactory::create<LLButton>(button_p));
+ getChildRef<LLLayoutPanel>("background_area").setBackgroundVisible(false);
+ setMouseOpaque(false);
}
+}
+
+void LLWindowShade::hide()
+{
+ getChildRef<LLLayoutPanel>("notification_area").setVisible(false);
+}
+
+void LLWindowShade::onCloseNotification()
+{
+ if (!mNotifications.empty())
+ LLNotifications::instance().cancel(mNotifications.back());
+}
+
+void LLWindowShade::onClickIgnore(LLUICtrl* ctrl)
+{
+ LLNotificationPtr notify = getCurrentNotification();
+ if (!notify) return;
+
+ bool check = ctrl->getValue().asBoolean();
+ if (notify->getForm()->getIgnoreType() == LLNotificationForm::IGNORE_SHOW_AGAIN)
+ {
+ // question was "show again" so invert value to get "ignore"
+ check = !check;
+ }
+ notify->setIgnored(check);
+}
+
+void LLWindowShade::onClickNotificationButton(const std::string& name)
+{
+ LLNotificationPtr notify = getCurrentNotification();
+ if (!notify) return;
- LLSD payload = mNotification->getPayload();
+ mNotificationResponse[name] = true;
+
+ notify->respond(mNotificationResponse);
+}
- LLNotificationFormPtr formp = mNotification->getForm();
+void LLWindowShade::onEnterNotificationText(LLUICtrl* ctrl, const std::string& name)
+{
+ mNotificationResponse[name] = ctrl->getValue().asString();
+}
+
+void LLWindowShade::show(LLNotificationPtr notification)
+{
+ mNotifications.push_back(notification);
+
+ displayLatestNotification();
+}
+
+void LLWindowShade::displayLatestNotification()
+{
+ if (mNotifications.empty()) return;
+
+ LLNotificationPtr notification = mNotifications.back();
+
+ LLSD payload = notification->getPayload();
+
+ LLNotificationFormPtr formp = notification->getForm();
LLLayoutPanel& notification_area = getChildRef<LLLayoutPanel>("notification_area");
- notification_area.getChild<LLUICtrl>("notification_icon")->setValue(mNotification->getIcon());
- notification_area.getChild<LLUICtrl>("notification_text")->setValue(mNotification->getMessage());
- notification_area.getChild<LLUICtrl>("notification_text")->setToolTip(mNotification->getMessage());
+ notification_area.getChild<LLUICtrl>("notification_icon")->setValue(notification->getIcon());
+ notification_area.getChild<LLUICtrl>("notification_text")->setValue(notification->getMessage());
+ notification_area.getChild<LLUICtrl>("notification_text")->setToolTip(notification->getMessage());
LLNotificationForm::EIgnoreType ignore_type = formp->getIgnoreType();
LLLayoutPanel& form_elements = notification_area.getChildRef<LLLayoutPanel>("form_elements");
form_elements.deleteAllChildren();
+ form_elements.reshape(form_elements.getRect().getWidth(), MIN_NOTIFICATION_AREA_HEIGHT);
const S32 FORM_PADDING_HORIZONTAL = 10;
const S32 FORM_PADDING_VERTICAL = 3;
@@ -229,7 +322,7 @@ void LLWindowShade::initFromParams(const LLWindowShade::Params& params)
label_p.v_pad = 5;
LLTextBox* textbox = LLUICtrlFactory::create<LLTextBox>(label_p);
textbox->reshapeToFitText();
- textbox->reshape(textbox->getRect().getWidth(), form_elements.getRect().getHeight() - 2 * FORM_PADDING_VERTICAL);
+ textbox->reshape(textbox->getRect().getWidth(), MIN_NOTIFICATION_AREA_HEIGHT - 2 * FORM_PADDING_VERTICAL);
form_elements.addChild(textbox);
cur_x = textbox->getRect().mRight + FORM_PADDING_HORIZONTAL;
@@ -249,7 +342,7 @@ void LLWindowShade::initFromParams(const LLWindowShade::Params& params)
}
}
- mFormHeight = form_elements.getRect().getHeight() - (cur_y - FORM_PADDING_VERTICAL) + WIDGET_HEIGHT;
+ mFormHeight = form_elements.getRect().getHeight() - (cur_y - WIDGET_HEIGHT - FORM_PADDING_VERTICAL);
form_elements.reshape(form_width, mFormHeight);
form_elements.setMinDim(form_width);
@@ -261,68 +354,39 @@ void LLWindowShade::initFromParams(const LLWindowShade::Params& params)
{
(*it)->translate(0, delta_y);
}
-}
-void LLWindowShade::show()
-{
getChildRef<LLLayoutPanel>("notification_area").setVisible(true);
getChildRef<LLLayoutPanel>("background_area").setBackgroundVisible(mModal);
setMouseOpaque(mModal);
}
-void LLWindowShade::draw()
+void LLWindowShade::setBackgroundImage(LLUIImage* image)
{
- LLRect message_rect = getChild<LLTextBox>("notification_text")->getTextBoundingRect();
-
- LLLayoutPanel* notification_area = getChild<LLLayoutPanel>("notification_area");
-
- notification_area->reshape(notification_area->getRect().getWidth(),
- llclamp(message_rect.getHeight() + 10,
- llmin(mFormHeight, MAX_NOTIFICATION_AREA_HEIGHT),
- MAX_NOTIFICATION_AREA_HEIGHT));
-
- LLUICtrl::draw();
- if (mNotification && !mNotification->isActive())
- {
- hide();
- }
+ getChild<LLLayoutPanel>("notification_area")->setTransparentImage(image);
}
-void LLWindowShade::hide()
+void LLWindowShade::setTextColor(LLColor4 color)
{
- getChildRef<LLLayoutPanel>("notification_area").setVisible(false);
- getChildRef<LLLayoutPanel>("background_area").setBackgroundVisible(false);
-
- setMouseOpaque(false);
+ getChild<LLTextBox>("notification_text")->setColor(color);
}
-void LLWindowShade::onCloseNotification()
+bool LLWindowShade::isShown() const
{
- LLNotifications::instance().cancel(mNotification);
+ return getChildRef<LLLayoutPanel>("notification_area").getVisible();
}
-void LLWindowShade::onClickIgnore(LLUICtrl* ctrl)
+void LLWindowShade::setCanClose(bool can_close)
{
- bool check = ctrl->getValue().asBoolean();
- if (mNotification && mNotification->getForm()->getIgnoreType() == LLNotificationForm::IGNORE_SHOW_AGAIN)
- {
- // question was "show again" so invert value to get "ignore"
- check = !check;
- }
- mNotification->setIgnored(check);
+ getChildView("close_panel")->setVisible(can_close);
}
-void LLWindowShade::onClickNotificationButton(const std::string& name)
+LLNotificationPtr LLWindowShade::getCurrentNotification()
{
- if (!mNotification) return;
-
- mNotificationResponse[name] = true;
-
- mNotification->respond(mNotificationResponse);
+ if (mNotifications.empty())
+ {
+ return LLNotificationPtr();
+ }
+ return mNotifications.back();
}
-void LLWindowShade::onEnterNotificationText(LLUICtrl* ctrl, const std::string& name)
-{
- mNotificationResponse[name] = ctrl->getValue().asString();
-}
diff --git a/indra/llui/llwindowshade.h b/indra/llui/llwindowshade.h
index 09ffc2cd54..6d753d1161 100644
--- a/indra/llui/llwindowshade.h
+++ b/indra/llui/llwindowshade.h
@@ -36,20 +36,28 @@ class LLWindowShade : public LLUICtrl
public:
struct Params : public LLInitParam::Block<Params, LLUICtrl::Params>
{
- Mandatory<LLNotificationPtr> notification;
Optional<LLUIImage*> bg_image;
- Optional<LLUIColor> text_color;
+ Optional<LLUIColor> text_color,
+ shade_color;
Optional<bool> modal,
can_close;
Params();
};
- void show();
+ void show(LLNotificationPtr);
/*virtual*/ void draw();
void hide();
+
+ bool isShown() const;
+
+ void setBackgroundImage(LLUIImage* image);
+ void setTextColor(LLColor4 color);
+ void setCanClose(bool can_close);
private:
+ void displayLatestNotification();
+ LLNotificationPtr getCurrentNotification();
friend class LLUICtrlFactory;
LLWindowShade(const Params& p);
@@ -60,7 +68,7 @@ private:
void onEnterNotificationText(LLUICtrl* ctrl, const std::string& name);
void onClickIgnore(LLUICtrl* ctrl);
- LLNotificationPtr mNotification;
+ std::vector<LLNotificationPtr> mNotifications;
LLSD mNotificationResponse;
bool mModal;
S32 mFormHeight;
generated by cgit v1.2.3 (git 2.25.1) at 2025-02-20 23:19:01 +0000