merge

7 files changed, 244 insertions, 64 deletions

diff --git a/indra/llui/llfloater.cpp b/indra/llui/llfloater.cpp
index 09e27a264a..d97569839a 100644
--- a/indra/llui/llfloater.cpp
+++ b/indra/llui/llfloater.cpp
@@ -507,22 +507,11 @@ LLFloater::~LLFloater()
 {
 	LLFloaterReg::removeInstance(mInstanceName, mKey);
 	
-//	delete mNotificationContext;
-//	mNotificationContext = NULL;
-
-	//// am I not hosted by another floater?
-	//if (mHostHandle.isDead())
-	//{
-	//	LLFloaterView* parent = (LLFloaterView*) getParent();
-
-	//	if( parent )
-	//	{
-	//		parent->removeChild( this );
-	//	}
-	//}
-
-	// Just in case we might still have focus here, release it.
-	releaseFocus();
+	if( gFocusMgr.childHasKeyboardFocus(this))
+	{
+		// Just in case we might still have focus here, release it.
+		releaseFocus();
+	}
 
 	// This is important so that floaters with persistent rects (i.e., those
 	// created with rect control rather than an LLRect) are restored in their
@@ -2788,7 +2777,7 @@ void LLFloaterView::adjustToFitScreen(LLFloater* floater, BOOL allow_partial_out
 	}
 
 	// move window fully onscreen
-	if (floater->translateIntoRect( getSnapRect(), allow_partial_outside ? FLOATER_MIN_VISIBLE_PIXELS : S32_MAX ))
+	if (floater->translateIntoRect( gFloaterView->getRect(), allow_partial_outside ? FLOATER_MIN_VISIBLE_PIXELS : S32_MAX ))
 	{
 		floater->clearSnapTarget();
 	}
@@ -3258,6 +3247,11 @@ bool LLFloater::isShown() const
     return ! isMinimized() && isInVisibleChain();
 }
 
+bool LLFloater::isDetachedAndNotMinimized()
+{
+	return !getHost() && !isMinimized();
+}
+
 /* static */
 bool LLFloater::isShown(const LLFloater* floater)
 {
diff --git a/indra/llui/llfloater.h b/indra/llui/llfloater.h
index 4dba1e645f..26ac4a98ad 100644
--- a/indra/llui/llfloater.h
+++ b/indra/llui/llfloater.h
@@ -238,6 +238,7 @@ public:
 	void			center();
 
 	LLMultiFloater* getHost();
+	bool isDetachedAndNotMinimized();
 
 	void			applyTitle();
 	std::string		getCurrentTitle() const;
diff --git a/indra/llui/lllayoutstack.cpp b/indra/llui/lllayoutstack.cpp
index e642883991..c89c0203b4 100644
--- a/indra/llui/lllayoutstack.cpp
+++ b/indra/llui/lllayoutstack.cpp
@@ -214,8 +214,15 @@ LLLayoutStack::Params::Params()
 	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))
-{}
+	border_size("border_size", LLCachedControl<S32>(*LLUI::sSettingGroups["config"], "UIResizeBarHeight", 0)),
+	show_drag_handle("show_drag_handle", false),
+	drag_handle_first_indent("drag_handle_first_indent", 0),
+	drag_handle_second_indent("drag_handle_second_indent", 0),
+	drag_handle_thickness("drag_handle_thickness", 5),
+	drag_handle_shift("drag_handle_shift", 2)
+{
+	addSynonym(border_size, "drag_handle_gap");
+}
 
 LLLayoutStack::LLLayoutStack(const LLLayoutStack::Params& p) 
 :	LLView(p),
@@ -227,8 +234,14 @@ LLLayoutStack::LLLayoutStack(const LLLayoutStack::Params& p)
 	mClip(p.clip),
 	mOpenTimeConstant(p.open_time_constant),
 	mCloseTimeConstant(p.close_time_constant),
-	mResizeBarOverlap(p.resize_bar_overlap)
-{}
+	mResizeBarOverlap(p.resize_bar_overlap),
+	mShowDragHandle(p.show_drag_handle),
+	mDragHandleFirstIndent(p.drag_handle_first_indent),
+	mDragHandleSecondIndent(p.drag_handle_second_indent),
+	mDragHandleThickness(p.drag_handle_thickness),
+	mDragHandleShift(p.drag_handle_shift)
+{
+}
 
 LLLayoutStack::~LLLayoutStack()
 {
@@ -262,6 +275,26 @@ void LLLayoutStack::draw()
 			drawChild(panelp, 0, 0, !clip_rect.isEmpty());
 		}
 	}
+
+	const LLView::child_list_t * child_listp = getChildList();
+	BOOST_FOREACH(LLView * childp, * child_listp)
+	{
+		LLResizeBar * resize_barp = dynamic_cast<LLResizeBar*>(childp);
+		if (resize_barp && resize_barp->isShowDragHandle() && resize_barp->getVisible() && resize_barp->getRect().isValid())
+		{
+			LLRect screen_rect = resize_barp->calcScreenRect();
+			if (LLUI::getRootView()->getLocalRect().overlaps(screen_rect) && LLUI::sDirtyRect.overlaps(screen_rect))
+			{
+				LLUI::pushMatrix();
+				{
+					const LLRect& rb_rect(resize_barp->getRect());
+					LLUI::translate(rb_rect.mLeft, rb_rect.mBottom);
+					resize_barp->draw();
+				}
+				LLUI::popMatrix();
+			}
+		}
+	}
 }
 
 void LLLayoutStack::removeChild(LLView* view)
@@ -390,7 +423,6 @@ void LLLayoutStack::updateLayout()
 	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)
@@ -407,27 +439,61 @@ void LLLayoutStack::updateLayout()
 										getRect().getWidth(),
 										llround(panel_dim));
 		}
-		panelp->setIgnoreReshape(true);
-		panelp->setShape(panel_rect);
-		panelp->setIgnoreReshape(false);
 
 		LLRect resize_bar_rect(panel_rect);
-
+		LLResizeBar * resize_barp = panelp->getResizeBar();
+		bool show_drag_handle = resize_barp->isShowDragHandle();
 		F32 panel_spacing = (F32)mPanelSpacing * panelp->getVisibleAmount();
+		F32 panel_visible_dim = panelp->getVisibleDim();
+		S32 panel_spacing_round = (S32)(llround(panel_spacing));
+
 		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;
+
+			if (show_drag_handle && panel_spacing_round > mDragHandleThickness)
+			{
+				resize_bar_rect.mLeft = panel_rect.mRight + mDragHandleShift;
+				resize_bar_rect.mRight = resize_bar_rect.mLeft + mDragHandleThickness;
+			}
+			else
+			{
+				resize_bar_rect.mLeft = panel_rect.mRight - mResizeBarOverlap;
+				resize_bar_rect.mRight = panel_rect.mRight + panel_spacing_round + mResizeBarOverlap;
+			}
+
+			if (show_drag_handle)
+			{
+				resize_bar_rect.mBottom += mDragHandleSecondIndent;
+				resize_bar_rect.mTop -= mDragHandleFirstIndent;
+			}
+
 		}
 		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;
+
+			if (show_drag_handle && panel_spacing_round > mDragHandleThickness)
+			{
+				resize_bar_rect.mTop = panel_rect.mBottom - mDragHandleShift;
+				resize_bar_rect.mBottom = resize_bar_rect.mTop - mDragHandleThickness;
+			}
+			else
+			{
+				resize_bar_rect.mTop = panel_rect.mBottom + mResizeBarOverlap;
+				resize_bar_rect.mBottom = panel_rect.mBottom - panel_spacing_round - mResizeBarOverlap;
+			}
+
+			if (show_drag_handle)
+			{
+				resize_bar_rect.mLeft += mDragHandleFirstIndent;
+				resize_bar_rect.mRight -= mDragHandleSecondIndent;
+			}
 		}
+
+		panelp->setIgnoreReshape(true);
+		panelp->setShape(panel_rect);
+		panelp->setIgnoreReshape(false);
 		panelp->mResizeBar->setShape(resize_bar_rect);
 	}
 
@@ -475,15 +541,13 @@ void LLLayoutStack::createResizeBar(LLLayoutPanel* panelp)
 	{
 		if (lp->mResizeBar == NULL)
 		{
-			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.side((mOrientation == HORIZONTAL) ? LLResizeBar::RIGHT : LLResizeBar::BOTTOM);
 			resize_params.snapping_enabled(false);
+			resize_params.show_drag_handle(mShowDragHandle);
 			LLResizeBar* resize_bar = LLUICtrlFactory::create<LLResizeBar>(resize_params);
 			lp->mResizeBar = resize_bar;
 			LLView::addChild(resize_bar, 0);
@@ -865,3 +929,4 @@ void LLLayoutStack::updateResizeBarLimits()
 		previous_visible_panelp = visible_panelp;
 	}
 }
+
diff --git a/indra/llui/lllayoutstack.h b/indra/llui/lllayoutstack.h
index 02c664f1a0..b570974bd6 100644
--- a/indra/llui/lllayoutstack.h
+++ b/indra/llui/lllayoutstack.h
@@ -62,6 +62,11 @@ public:
 		Optional<F32>			open_time_constant,
 								close_time_constant;
 		Optional<S32>			resize_bar_overlap;
+		Optional<bool>			show_drag_handle;
+		Optional<S32>			drag_handle_first_indent;
+		Optional<S32>			drag_handle_second_indent;
+		Optional<S32>			drag_handle_thickness;
+		Optional<S32>			drag_handle_shift;
 
 		Params();
 	};
@@ -126,6 +131,11 @@ private:
 	F32  mCloseTimeConstant;
 	bool mNeedsLayout;
 	S32  mResizeBarOverlap;
+	bool mShowDragHandle;
+	S32  mDragHandleFirstIndent;
+	S32  mDragHandleSecondIndent;
+	S32  mDragHandleThickness;
+	S32  mDragHandleShift;
 }; // end class LLLayoutStack
 
 
diff --git a/indra/llui/llresizebar.cpp b/indra/llui/llresizebar.cpp
index 15e56cbfe5..e67b22c977 100644
--- a/indra/llui/llresizebar.cpp
+++ b/indra/llui/llresizebar.cpp
@@ -28,14 +28,53 @@
 
 #include "llresizebar.h"
 
+#include "lllocalcliprect.h"
 #include "llmath.h"
 #include "llui.h"
 #include "llmenugl.h"
 #include "llfocusmgr.h"
 #include "llwindow.h"
 
+class LLImagePanel : public LLPanel
+{
+public:
+	struct Params :	public LLInitParam::Block<Params, LLPanel::Params>
+	{
+		Optional<bool> horizontal;
+		Params() : horizontal("horizontal", false) {}
+	};
+	LLImagePanel(const Params& p) : LLPanel(p), mHorizontal(p.horizontal) {}
+	virtual ~LLImagePanel() {}
+
+	void draw()
+	{
+		const LLRect& parent_rect = getParent()->getRect();
+		const LLRect& rect = getRect();
+		LLRect clip_rect( -rect.mLeft, parent_rect.getHeight() - rect.mBottom - 2
+						 , parent_rect.getWidth() - rect.mLeft - (mHorizontal ? 2 : 0), -rect.mBottom);
+		LLLocalClipRect clip(clip_rect);
+		LLPanel::draw();
+	}
+
+private:
+	bool mHorizontal;
+};
+
+static LLDefaultChildRegistry::Register<LLImagePanel> t1("resize_bar_image_panel");
+
+LLResizeBar::Params::Params()
+:	max_size("max_size", S32_MAX),
+	snapping_enabled("snapping_enabled", true),
+	resizing_view("resizing_view"),
+	side("side"),
+	allow_double_click_snapping("allow_double_click_snapping", true),
+	show_drag_handle("show_drag_handle", false)
+{
+	name = "resize_bar";
+}
+
 LLResizeBar::LLResizeBar(const LLResizeBar::Params& p)
-:	LLView(p),
+:	LLPanel(p),
 	mDragLastScreenX( 0 ),
 	mDragLastScreenY( 0 ),
 	mLastMouseScreenX( 0 ),
@@ -46,7 +85,9 @@ LLResizeBar::LLResizeBar(const LLResizeBar::Params& p)
 	mSnappingEnabled(p.snapping_enabled),
 	mAllowDoubleClickSnapping(p.allow_double_click_snapping),
 	mResizingView(p.resizing_view),
-	mResizeListener(NULL)
+	mResizeListener(NULL),
+	mShowDragHandle(p.show_drag_handle),
+	mImagePanel(NULL)
 {
 	setFollowsNone();
 	// set up some generically good follow code.
@@ -75,8 +116,37 @@ LLResizeBar::LLResizeBar(const LLResizeBar::Params& p)
 	default:
 		break;
 	}
+
+	if (mShowDragHandle)
+	{
+		LLViewBorder::Params border_params;
+		border_params.border_thickness = 1;
+		border_params.highlight_light_color = LLUIColorTable::instance().getColor("ResizebarBorderLight");
+		border_params.shadow_dark_color = LLUIColorTable::instance().getColor("ResizebarBorderDark");
+
+		addBorder(border_params);
+		setBorderVisible(TRUE);
+
+		LLImagePanel::Params image_panel;
+		mDragHandleImage = LLUI::getUIImage(LLResizeBar::RIGHT == mSide ? "Vertical Drag Handle" : "Horizontal Drag Handle");
+		image_panel.bg_alpha_image = mDragHandleImage;
+		image_panel.background_visible = true;
+		image_panel.horizontal = (LLResizeBar::BOTTOM == mSide);
+		mImagePanel = LLUICtrlFactory::create<LLImagePanel>(image_panel);
+		setImagePanel(mImagePanel);
+	}
 }
 
+BOOL LLResizeBar::postBuild()
+{
+	if (mShowDragHandle)
+	{
+		setBackgroundVisible(TRUE);
+		setTransparentColor(LLUIColorTable::instance().getColor("ResizebarBody"));
+	}
+
+	return LLPanel::postBuild();
+}
 
 BOOL LLResizeBar::handleMouseDown(S32 x, S32 y, MASK mask)
 {
@@ -342,3 +412,39 @@ BOOL LLResizeBar::handleDoubleClick(S32 x, S32 y, MASK mask)
 	return TRUE;
 }
 
+void LLResizeBar::setImagePanel(LLPanel * panelp)
+{
+	const LLView::child_list_t * children = getChildList();
+	if (getChildCount() == 2)
+	{
+		LLPanel * image_panelp = dynamic_cast<LLPanel*>(children->back());
+		if (image_panelp)
+		{
+			removeChild(image_panelp);
+			delete image_panelp;
+		}
+	}
+
+	addChild(panelp);
+	sendChildToBack(panelp);
+}
+
+LLPanel * LLResizeBar::getImagePanel() const
+{
+	return getChildCount() > 0 ? (LLPanel *)getChildList()->back() : NULL;
+}
+
+void LLResizeBar::draw()
+{
+	if (mShowDragHandle)
+	{
+		S32 image_width = mDragHandleImage->getTextureWidth();
+		S32 image_height = mDragHandleImage->getTextureHeight();
+		const LLRect& panel_rect = getRect();
+		S32 image_left = (panel_rect.getWidth() - image_width) / 2 - 1;
+		S32 image_bottom = (panel_rect.getHeight() - image_height) / 2;
+		mImagePanel->setRect(LLRect(image_left, image_bottom + image_height, image_left + image_width, image_bottom));
+	}
+
+	LLPanel::draw();
+}
diff --git a/indra/llui/llresizebar.h b/indra/llui/llresizebar.h
index 8190a95a71..bcf8ea0b40 100644
--- a/indra/llui/llresizebar.h
+++ b/indra/llui/llresizebar.h
@@ -27,15 +27,14 @@
 #ifndef LL_RESIZEBAR_H
 #define LL_RESIZEBAR_H
 
-#include "llview.h"
-#include "llcoord.h"
+#include "llpanel.h"
 
-class LLResizeBar : public LLView
+class LLResizeBar : public LLPanel
 {
 public:
 	enum Side { LEFT, TOP, RIGHT, BOTTOM };
 
-	struct Params : public LLInitParam::Block<Params, LLView::Params>
+	struct Params : public LLInitParam::Block<Params, LLPanel::Params>
 	{
 		Mandatory<LLView*> resizing_view;
 		Mandatory<Side>	side;
@@ -44,24 +43,19 @@ public:
 		Optional<S32>	max_size;
 		Optional<bool>	snapping_enabled;
 		Optional<bool>	allow_double_click_snapping;
+		Optional<bool>	show_drag_handle;
 
-		Params()
-		:	max_size("max_size", S32_MAX),
-			snapping_enabled("snapping_enabled", true),
-			resizing_view("resizing_view"),
-			side("side"),
-			allow_double_click_snapping("allow_double_click_snapping", true)
-		{
-			name = "resize_bar";
-		}
+		Params();
 	};
 
 protected:
 	LLResizeBar(const LLResizeBar::Params& p);
 	friend class LLUICtrlFactory;
+
+	/*virtual*/ BOOL postBuild();
 public:
 
-//	virtual void	draw();  No appearance
+	virtual void	draw();
 	virtual BOOL	handleHover(S32 x, S32 y, MASK mask);
 	virtual BOOL	handleMouseDown(S32 x, S32 y, MASK mask);
 	virtual BOOL	handleMouseUp(S32 x, S32 y, MASK mask);
@@ -72,20 +66,26 @@ public:
 	void			setAllowDoubleClickSnapping(BOOL allow) { mAllowDoubleClickSnapping = allow; }
 	bool			canResize() { return getEnabled() && mMaxSize > mMinSize; }
 	void            setResizeListener(boost::function<void(void*)> listener) {mResizeListener = listener;}
+	BOOL			isShowDragHandle() const { return mShowDragHandle; }
+	void			setImagePanel(LLPanel * panelp);
+	LLPanel *		getImagePanel() const;
 
 private:
-	S32				mDragLastScreenX;
-	S32				mDragLastScreenY;
-	S32				mLastMouseScreenX;
-	S32				mLastMouseScreenY;
-	LLCoordGL		mLastMouseDir;
-	S32				mMinSize;
-	S32				mMaxSize;
-	const Side		mSide;
-	BOOL			mSnappingEnabled;
-	BOOL			mAllowDoubleClickSnapping;
-	LLView*			mResizingView;
-	boost::function<void(void*)>  mResizeListener;
+	S32								mDragLastScreenX;
+	S32								mDragLastScreenY;
+	S32								mLastMouseScreenX;
+	S32								mLastMouseScreenY;
+	LLCoordGL						mLastMouseDir;
+	S32								mMinSize;
+	S32								mMaxSize;
+	const Side						mSide;
+	BOOL							mSnappingEnabled;
+	BOOL							mAllowDoubleClickSnapping;
+	BOOL							mShowDragHandle;
+	LLView*							mResizingView;
+	boost::function<void(void*)>	mResizeListener;
+	LLPointer<LLUIImage>			mDragHandleImage;
+	LLPanel *						mImagePanel;
 };
 
 #endif  // LL_RESIZEBAR_H
diff --git a/indra/llui/lltextbase.cpp b/indra/llui/lltextbase.cpp
index a815cfc176..def1277ba7 100644
--- a/indra/llui/lltextbase.cpp
+++ b/indra/llui/lltextbase.cpp
@@ -652,6 +652,10 @@ void LLTextBase::drawText()
 			mSpellCheckEnd = end;
 		}
 	}
+	else
+	{
+		mMisspellRanges.clear();
+	}
 
 	LLTextSegmentPtr cur_segment = *seg_iter;