9 files changed, 309 insertions, 151 deletions

diff --git a/indra/llui/llfloater.cpp b/indra/llui/llfloater.cpp
index abb043f428..e9c980ad9a 100644
--- a/indra/llui/llfloater.cpp
+++ b/indra/llui/llfloater.cpp
@@ -303,12 +303,10 @@ void LLFloater::initFloater(const Params& p)
 		mButtonsEnabled[BUTTON_CLOSE] = TRUE;
 	}
 
-	// Help button: '?'
-	if ( !mHelpTopic.empty() )
-	{
-		mButtonsEnabled[BUTTON_HELP] = TRUE;
-	}
-
+	// Help button: '?' 
+	//SL-14050 Disable all Help question marks
+	mButtonsEnabled[BUTTON_HELP] = FALSE;
+	
 	// Minimize button only for top draggers
 	if ( !mDragOnLeft && mCanMinimize )
 	{
diff --git a/indra/llui/llfolderviewmodel.cpp b/indra/llui/llfolderviewmodel.cpp
index ea106b5fae..e95cc12520 100644
--- a/indra/llui/llfolderviewmodel.cpp
+++ b/indra/llui/llfolderviewmodel.cpp
@@ -29,6 +29,160 @@
 #include "llfolderviewmodel.h"
 #include "lltrans.h"
 
+// LLFolderViewModelItemCommon
+
+LLFolderViewModelItemCommon::LLFolderViewModelItemCommon(LLFolderViewModelInterface& root_view_model)
+    : mSortVersion(-1),
+    mPassedFilter(true),
+    mPassedFolderFilter(true),
+    mStringMatchOffsetFilter(std::string::npos),
+    mStringFilterSize(0),
+    mFolderViewItem(NULL),
+    mLastFilterGeneration(-1),
+    mLastFolderFilterGeneration(-1),
+    mMarkedDirtyGeneration(-1),
+    mMostFilteredDescendantGeneration(-1),
+    mParent(NULL),
+    mRootViewModel(root_view_model)
+{
+    mChildren.clear(); //???
+}
+
+LLFolderViewModelItemCommon::~LLFolderViewModelItemCommon()
+{
+    // Children don't belong to model, but to LLFolderViewItem, just mark them as having no parent
+    std::for_each(mChildren.begin(), mChildren.end(), [](LLFolderViewModelItem* c) {c->setParent(NULL); });
+
+    // Don't leave dead pointer in parent
+    if (mParent)
+    {
+        mParent->removeChild(this);
+    }
+}
+
+void LLFolderViewModelItemCommon::dirtyFilter()
+{
+    if (mMarkedDirtyGeneration < 0)
+    {
+        mMarkedDirtyGeneration = mLastFilterGeneration;
+    }
+    mLastFilterGeneration = -1;
+    mLastFolderFilterGeneration = -1;
+
+    // bubble up dirty flag all the way to root
+    if (mParent)
+    {
+        mParent->dirtyFilter();
+    }
+}
+
+void LLFolderViewModelItemCommon::dirtyDescendantsFilter()
+{
+    mMostFilteredDescendantGeneration = -1;
+    if (mParent)
+    {
+        mParent->dirtyDescendantsFilter();
+    }
+}
+
+//virtual
+void LLFolderViewModelItemCommon::addChild(LLFolderViewModelItem* child)
+{
+    // Avoid duplicates: bail out if that child is already present in the list
+    // Note: this happens when models are created before views
+    child_list_t::const_iterator iter;
+    for (iter = mChildren.begin(); iter != mChildren.end(); iter++)
+    {
+        if (child == *iter)
+        {
+            return;
+        }
+    }
+    mChildren.push_back(child);
+    child->setParent(this);
+    dirtyFilter();
+    requestSort();
+}
+
+//virtual
+void LLFolderViewModelItemCommon::removeChild(LLFolderViewModelItem* child)
+{
+    mChildren.remove(child);
+    child->setParent(NULL);
+    dirtyDescendantsFilter();
+    dirtyFilter();
+}
+
+//virtual
+void LLFolderViewModelItemCommon::clearChildren()
+{
+    // As this is cleaning the whole list of children wholesale, we do need to delete the pointed objects
+    // This is different and not equivalent to calling removeChild() on each child
+    std::for_each(mChildren.begin(), mChildren.end(), DeletePointer());
+    mChildren.clear();
+    dirtyDescendantsFilter();
+    dirtyFilter();
+}
+
+void LLFolderViewModelItemCommon::setPassedFilter(bool passed, S32 filter_generation, std::string::size_type string_offset /*= std::string::npos*/, std::string::size_type string_size /*= 0*/)
+{
+    mPassedFilter = passed;
+    mLastFilterGeneration = filter_generation;
+    mStringMatchOffsetFilter = string_offset;
+    mStringFilterSize = string_size;
+    mMarkedDirtyGeneration = -1;
+}
+
+void LLFolderViewModelItemCommon::setPassedFolderFilter(bool passed, S32 filter_generation)
+{
+    mPassedFolderFilter = passed;
+    mLastFolderFilterGeneration = filter_generation;
+}
+
+//virtual
+bool LLFolderViewModelItemCommon::potentiallyVisible()
+{
+    return passedFilter() // we've passed the filter
+        || (getLastFilterGeneration() < mRootViewModel.getFilter().getFirstSuccessGeneration()) // or we don't know yet
+        || descendantsPassedFilter();
+}
+
+//virtual
+bool LLFolderViewModelItemCommon::passedFilter(S32 filter_generation /*= -1*/)
+{
+    if (filter_generation < 0)
+    {
+        filter_generation = mRootViewModel.getFilter().getFirstSuccessGeneration();
+    }
+    bool passed_folder_filter = mPassedFolderFilter && (mLastFolderFilterGeneration >= filter_generation);
+    bool passed_filter = mPassedFilter && (mLastFilterGeneration >= filter_generation);
+    return passed_folder_filter && (passed_filter || descendantsPassedFilter(filter_generation));
+}
+
+//virtual
+bool LLFolderViewModelItemCommon::descendantsPassedFilter(S32 filter_generation /*= -1*/)
+{
+    if (filter_generation < 0)
+    {
+        filter_generation = mRootViewModel.getFilter().getFirstSuccessGeneration();
+    }
+    return mMostFilteredDescendantGeneration >= filter_generation;
+}
+
+// LLFolderViewModelCommon
+
+LLFolderViewModelCommon::LLFolderViewModelCommon()
+    : mTargetSortVersion(0),
+    mFolderView(NULL)
+{}
+
+//virtual
+void LLFolderViewModelCommon::requestSortAll()
+{
+    // sort everything
+    mTargetSortVersion++;
+}
+
 bool LLFolderViewModelCommon::needsSort(LLFolderViewModelItem* item)
 {
 	return item->getSortVersion() < mTargetSortVersion;
diff --git a/indra/llui/llfolderviewmodel.h b/indra/llui/llfolderviewmodel.h
index 84a1539094..ba8733c86d 100644
--- a/indra/llui/llfolderviewmodel.h
+++ b/indra/llui/llfolderviewmodel.h
@@ -38,7 +38,6 @@ enum EInventorySortGroup
 	SG_ITEM
 };
 
-class LLFontGL;
 class LLInventoryModel;
 class LLMenuGL;
 class LLUIImage;
@@ -231,134 +230,43 @@ protected:
 class LLFolderViewModelItemCommon : public LLFolderViewModelItem
 {
 public:
-	LLFolderViewModelItemCommon(LLFolderViewModelInterface& root_view_model)
-	:	mSortVersion(-1),
-		mPassedFilter(true),
-		mPassedFolderFilter(true),
-		mStringMatchOffsetFilter(std::string::npos),
-		mStringFilterSize(0),
-		mFolderViewItem(NULL),
-		mLastFilterGeneration(-1),
-		mLastFolderFilterGeneration(-1),
-		mMarkedDirtyGeneration(-1),
-		mMostFilteredDescendantGeneration(-1),
-		mParent(NULL),
-		mRootViewModel(root_view_model)
-	{
-		mChildren.clear();
-	}
+    LLFolderViewModelItemCommon(LLFolderViewModelInterface& root_view_model);
+    virtual ~LLFolderViewModelItemCommon() override;
 
-	void requestSort() { mSortVersion = -1; }
-	S32 getSortVersion() { return mSortVersion; }
-	void setSortVersion(S32 version) { mSortVersion = version;}
+	void requestSort() override { mSortVersion = -1; }
+	S32 getSortVersion() override { return mSortVersion; }
+	void setSortVersion(S32 version) override { mSortVersion = version;}
 
-	S32	getLastFilterGeneration() const { return mLastFilterGeneration; }
+	S32	getLastFilterGeneration() const override { return mLastFilterGeneration; }
 	S32	getLastFolderFilterGeneration() const { return mLastFolderFilterGeneration; }
-	S32	getMarkedDirtyGeneration() const { return mMarkedDirtyGeneration; }
-	void dirtyFilter()
-	{
-		if(mMarkedDirtyGeneration < 0)
-		{
-			mMarkedDirtyGeneration = mLastFilterGeneration;
-		}
-		mLastFilterGeneration = -1;
-		mLastFolderFilterGeneration = -1;
-
-		// bubble up dirty flag all the way to root
-		if (mParent)
-		{
-			mParent->dirtyFilter();
-		}	
-	}
-	void dirtyDescendantsFilter()
-	{
-		mMostFilteredDescendantGeneration = -1;
-		if (mParent)
-		{
-			mParent->dirtyDescendantsFilter();
-		}
-	}
-	bool hasFilterStringMatch();
-	std::string::size_type getFilterStringOffset();
-	std::string::size_type getFilterStringSize();
+	S32	getMarkedDirtyGeneration() const override { return mMarkedDirtyGeneration; }
+    void dirtyFilter() override;
+    void dirtyDescendantsFilter() override;
+	bool hasFilterStringMatch() override;
+	std::string::size_type getFilterStringOffset() override;
+	std::string::size_type getFilterStringSize() override;
 	
 	typedef std::list<LLFolderViewModelItem*> child_list_t;
 
-	virtual void addChild(LLFolderViewModelItem* child) 
-	{
-		mChildren.push_back(child);
-		child->setParent(this); 
-		dirtyFilter();
-		requestSort();
-	}
-	virtual void removeChild(LLFolderViewModelItem* child) 
-	{ 
-		mChildren.remove(child); 
-		child->setParent(NULL);
-		dirtyDescendantsFilter();
-		dirtyFilter();
-	}
+    virtual void addChild(LLFolderViewModelItem* child) override;
+    virtual void removeChild(LLFolderViewModelItem* child) override;
 	
-	virtual void clearChildren()
-	{
-		// As this is cleaning the whole list of children wholesale, we do need to delete the pointed objects
-		// This is different and not equivalent to calling removeChild() on each child
-		std::for_each(mChildren.begin(), mChildren.end(), DeletePointer());
-		mChildren.clear();
-		dirtyDescendantsFilter();
-		dirtyFilter();
-	}
+    virtual void clearChildren();
 	
 	child_list_t::const_iterator getChildrenBegin() const { return mChildren.begin(); }
 	child_list_t::const_iterator getChildrenEnd() const { return mChildren.end(); }
 	child_list_t::size_type getChildrenCount() const { return mChildren.size(); }
 	
-	void setPassedFilter(bool passed, S32 filter_generation, std::string::size_type string_offset = std::string::npos, std::string::size_type string_size = 0)
-	{
-		mPassedFilter = passed;
-		mLastFilterGeneration = filter_generation;
-		mStringMatchOffsetFilter = string_offset;
-		mStringFilterSize = string_size;
-		mMarkedDirtyGeneration = -1;
-	}
-
-	void setPassedFolderFilter(bool passed, S32 filter_generation)
-	{
-		mPassedFolderFilter = passed;
-		mLastFolderFilterGeneration = filter_generation;
-	}
-
-	virtual bool potentiallyVisible()
-	{
-		return passedFilter() // we've passed the filter
-			|| (getLastFilterGeneration() < mRootViewModel.getFilter().getFirstSuccessGeneration()) // or we don't know yet
-			|| descendantsPassedFilter();
-	}
-
-	virtual bool passedFilter(S32 filter_generation = -1) 
-	{ 
-		if (filter_generation < 0)
-        {
-			filter_generation = mRootViewModel.getFilter().getFirstSuccessGeneration();
-        }
-		bool passed_folder_filter = mPassedFolderFilter && (mLastFolderFilterGeneration >= filter_generation);
-		bool passed_filter = mPassedFilter && (mLastFilterGeneration >= filter_generation);
-		return passed_folder_filter && (passed_filter || descendantsPassedFilter(filter_generation));
-	}
-
-	virtual bool descendantsPassedFilter(S32 filter_generation = -1)
-	{ 
-		if (filter_generation < 0)
-        {
-            filter_generation = mRootViewModel.getFilter().getFirstSuccessGeneration();
-        }
-		return mMostFilteredDescendantGeneration >= filter_generation;
-	}
+    void setPassedFilter(bool passed, S32 filter_generation, std::string::size_type string_offset = std::string::npos, std::string::size_type string_size = 0) override;
+    void setPassedFolderFilter(bool passed, S32 filter_generation) override;
+    virtual bool potentiallyVisible() override;
+    virtual bool passedFilter(S32 filter_generation = -1) override;
+    virtual bool descendantsPassedFilter(S32 filter_generation = -1) override;
 
 
 protected:
-	virtual void setParent(LLFolderViewModelItem* parent) { mParent = parent; }
-	virtual bool hasParent() { return mParent != NULL; }
+	virtual void setParent(LLFolderViewModelItem* parent) override { mParent = parent; }
+	virtual bool hasParent() override { return mParent != NULL; }
 
 	S32							mSortVersion;
 	bool						mPassedFilter;
@@ -375,7 +283,7 @@ protected:
 	LLFolderViewModelItem*		mParent;
 	LLFolderViewModelInterface& mRootViewModel;
 
-	void setFolderViewItem(LLFolderViewItem* folder_view_item) { mFolderViewItem = folder_view_item;}
+	void setFolderViewItem(LLFolderViewItem* folder_view_item) override { mFolderViewItem = folder_view_item;}
 	LLFolderViewItem*		mFolderViewItem;
 };
 
@@ -384,20 +292,15 @@ protected:
 class LLFolderViewModelCommon : public LLFolderViewModelInterface
 {
 public:
-	LLFolderViewModelCommon()
-	:	mTargetSortVersion(0),
-		mFolderView(NULL)
-	{}
+    LLFolderViewModelCommon();
 
-	virtual void requestSortAll()
-	{
-		// sort everything
-		mTargetSortVersion++;
-	}
-	virtual std::string getStatusText();
-	virtual void filter();
+    virtual ~LLFolderViewModelCommon() override {}
+
+    virtual void requestSortAll() override;
+	virtual std::string getStatusText() override;
+	virtual void filter() override;
 
-	void setFolderView(LLFolderView* folder_view) { mFolderView = folder_view;}
+	void setFolderView(LLFolderView* folder_view) override { mFolderView = folder_view;}
 
 protected:
 	bool needsSort(class LLFolderViewModelItem* item);
@@ -421,7 +324,7 @@ public:
 		mFilter(filter)
 	{}
 
-	virtual ~LLFolderViewModel() 
+	virtual ~LLFolderViewModel() override
 	{
 		delete mSorter;
 		mSorter = NULL;
@@ -439,8 +342,8 @@ public:
 
 	// By default, we assume the content is available. If a network fetch mechanism is implemented for the model,
 	// this method needs to be overloaded and return the relevant fetch status.
-	virtual bool contentsReady()					{ return true; }
-	virtual bool isFolderComplete(LLFolderViewFolder* folder)					{ return true; }
+	virtual bool contentsReady() override						{ return true; }
+	virtual bool isFolderComplete(LLFolderViewFolder* folder) override { return true; }
 
 	struct ViewModelCompare
 	{
@@ -461,7 +364,7 @@ public:
 		const SortType& mSorter;
 	};
 
-	void sort(LLFolderViewFolder* folder)
+	void sort(LLFolderViewFolder* folder) override
 	{
 		if (needsSort(folder->getViewModelItem()))
 		{
diff --git a/indra/llui/llmenugl.cpp b/indra/llui/llmenugl.cpp
index 5568a84494..c2698fa648 100644
--- a/indra/llui/llmenugl.cpp
+++ b/indra/llui/llmenugl.cpp
@@ -79,7 +79,7 @@ const U32 LEFT_PAD_PIXELS = 3;
 const U32 LEFT_WIDTH_PIXELS = 15;
 const U32 LEFT_PLAIN_PIXELS = LEFT_PAD_PIXELS + LEFT_WIDTH_PIXELS;
 
-const U32 RIGHT_PAD_PIXELS = 2;
+const U32 RIGHT_PAD_PIXELS = 7;
 const U32 RIGHT_WIDTH_PIXELS = 15;
 const U32 RIGHT_PLAIN_PIXELS = RIGHT_PAD_PIXELS + RIGHT_WIDTH_PIXELS;
 
@@ -95,7 +95,7 @@ const std::string SEPARATOR_NAME("separator");
 const std::string VERTICAL_SEPARATOR_LABEL( "|" );
 
 const std::string LLMenuGL::BOOLEAN_TRUE_PREFIX( "\xE2\x9C\x94" ); // U+2714 HEAVY CHECK MARK
-const std::string LLMenuGL::BRANCH_SUFFIX( "\xE2\x96\xB6" ); // U+25B6 BLACK RIGHT-POINTING TRIANGLE
+const std::string LLMenuGL::BRANCH_SUFFIX( "\xe2\x96\xb8" ); // U+25B6 BLACK RIGHT-POINTING TRIANGLE
 const std::string LLMenuGL::ARROW_UP  ("^^^^^^^");
 const std::string LLMenuGL::ARROW_DOWN("vvvvvvv");
 
diff --git a/indra/llui/llscrolllistctrl.cpp b/indra/llui/llscrolllistctrl.cpp
index 367c6c3c5b..dc525517bf 100644
--- a/indra/llui/llscrolllistctrl.cpp
+++ b/indra/llui/llscrolllistctrl.cpp
@@ -1381,18 +1381,34 @@ BOOL LLScrollListCtrl::setSelectedByValue(const LLSD& value, BOOL selected)
 	for (iter = mItemList.begin(); iter != mItemList.end(); iter++)
 	{
 		LLScrollListItem* item = *iter;
-		if (item->getEnabled() && (item->getValue().asString() == value.asString()))
-		{
-			if (selected)
-			{
-				selectItem(item);
-			}
-			else
-			{
-				deselectItem(item);
-			}
-			found = TRUE;
-			break;
+		if (item->getEnabled())
+		{
+            if (value.isBinary())
+            {
+                if (item->getValue().isBinary())
+                {
+                    LLSD::Binary data1 = value.asBinary();
+                    LLSD::Binary data2 = item->getValue().asBinary();
+                    found = std::equal(data1.begin(), data1.end(), data2.begin()) ? TRUE : FALSE;
+                }
+            }
+            else
+            {
+                found = item->getValue().asString() == value.asString() ? TRUE : FALSE;
+            }
+
+            if (found)
+            {
+                if (selected)
+                {
+                    selectItem(item);
+                }
+                else
+                {
+                    deselectItem(item);
+                }
+                break;
+            }
 		}
 	}
 
diff --git a/indra/llui/llurlentry.cpp b/indra/llui/llurlentry.cpp
index e6835f73fb..a69c0eb008 100644
--- a/indra/llui/llurlentry.cpp
+++ b/indra/llui/llurlentry.cpp
@@ -1481,4 +1481,43 @@ void LLUrlEntryExperienceProfile::onExperienceDetails( const LLSD& experience_de
     callObservers(experience_details[LLExperienceCache::EXPERIENCE_ID].asString(), name, LLStringUtil::null);
 }
 
+//
+// LLUrlEntryEmail Describes an IPv6 address
+//
+LLUrlEntryIPv6::LLUrlEntryIPv6()
+	: LLUrlEntryBase()
+{
+	mHostPath = "https?://\\[([a-f0-9:]+:+)+[a-f0-9]+]";
+	mPattern = boost::regex(mHostPath + "(:\\d{1,5})?(/\\S*)?",
+		boost::regex::perl | boost::regex::icase);
+	mMenuName = "menu_url_http.xml";
+	mTooltip = LLTrans::getString("TooltipHttpUrl");
+}
 
+std::string LLUrlEntryIPv6::getLabel(const std::string &url, const LLUrlLabelCallback &cb)
+{
+	boost::regex regex = boost::regex(mHostPath, boost::regex::perl | boost::regex::icase);
+	boost::match_results<std::string::const_iterator> matches;
+
+	if (boost::regex_search(url, matches, regex))
+	{
+		return  url.substr(0, matches[0].length());
+	}
+	else
+	{
+		return url;
+	}
+}
+
+std::string LLUrlEntryIPv6::getQuery(const std::string &url) const
+{
+	boost::regex regex = boost::regex(mHostPath, boost::regex::perl | boost::regex::icase);
+	boost::match_results<std::string::const_iterator> matches;
+
+	return boost::regex_replace(url, regex, "");
+}
+
+std::string LLUrlEntryIPv6::getUrl(const std::string &string) const
+{
+	return string;
+}
diff --git a/indra/llui/llurlentry.h b/indra/llui/llurlentry.h
index 78c149d9fd..0a0c247a6a 100644
--- a/indra/llui/llurlentry.h
+++ b/indra/llui/llurlentry.h
@@ -513,5 +513,18 @@ public:
 	/*virtual*/ std::string getUrl(const std::string &string) const;
 };
 
+///
+/// LLUrlEntryEmail Describes an IPv6 address
+///
+class LLUrlEntryIPv6 : public LLUrlEntryBase
+{
+public:
+	LLUrlEntryIPv6();
+	/*virtual*/ std::string getLabel(const std::string &url, const LLUrlLabelCallback &cb);
+	/*virtual*/ std::string getUrl(const std::string &string) const;
+	/*virtual*/ std::string getQuery(const std::string &url) const;
+
+	std::string mHostPath;
+};
 
 #endif
diff --git a/indra/llui/llurlregistry.cpp b/indra/llui/llurlregistry.cpp
index ba6fa1e2e9..321a0ec5b9 100644
--- a/indra/llui/llurlregistry.cpp
+++ b/indra/llui/llurlregistry.cpp
@@ -79,6 +79,7 @@ LLUrlRegistry::LLUrlRegistry()
 	mUrlEntrySLLabel = new LLUrlEntrySLLabel();
 	registerUrl(mUrlEntrySLLabel);
 	registerUrl(new LLUrlEntryEmail());
+	registerUrl(new LLUrlEntryIPv6());
 }
 
 LLUrlRegistry::~LLUrlRegistry()
diff --git a/indra/llui/tests/llurlentry_test.cpp b/indra/llui/tests/llurlentry_test.cpp
index 3c34fd269e..4a4fdb72e3 100644
--- a/indra/llui/tests/llurlentry_test.cpp
+++ b/indra/llui/tests/llurlentry_test.cpp
@@ -903,4 +903,38 @@ namespace tut
 				  "and even no www something lindenlab.com",
 				  "");
 	}
+
+	template<> template<>
+	void object::test<16>()
+	{
+		//
+		// test LLUrlEntryIPv6
+		//
+		LLUrlEntryIPv6 url;
+
+		// Regex tests.
+		testRegex("match urls with a protocol", url,
+			"this url should match http://[::1]",
+			"http://[::1]");
+
+		testRegex("match urls with a protocol and query", url,
+			"this url should match http://[::1]/file.mp3",
+			"http://[::1]/file.mp3");
+
+		testRegex("match urls with a protocol", url,
+			"this url should match http://[2001:0db8:11a3:09d7:1f34:8a2e:07a0:765d]",
+			"http://[2001:0db8:11a3:09d7:1f34:8a2e:07a0:765d]");
+
+		testRegex("match urls with port", url,
+			"let's specify some port http://[2001:0db8:11a3:09d7:1f34:8a2e:07a0:765d]:8080",
+			"http://[2001:0db8:11a3:09d7:1f34:8a2e:07a0:765d]:8080");
+
+		testRegex("don't match urls w/o protocol", url,
+			"looks like an url something [2001:0db8:11a3:09d7:1f34:8a2e:07a0:765d] but no https prefix",
+			"");
+
+		testRegex("don't match incorrect urls", url,
+			"http://[ 2001:0db8:11a3:09d7:1f34:8a2e:07a0:765d ]",
+			"");
+	}
 }