CHUI-101 WIP Make LLFolderView general purpose

continuing fixing build errors
general cleanup

13 files changed, 342 insertions, 356 deletions

diff --git a/indra/newview/llfolderview.cpp b/indra/newview/llfolderview.cpp
index 918e68e444..f0edbb638a 100644
--- a/indra/newview/llfolderview.cpp
+++ b/indra/newview/llfolderview.cpp
@@ -32,12 +32,8 @@
 #include "llcallbacklist.h"
 #include "llinventorybridge.h"
 #include "llclipboard.h" // *TODO: remove this once hack below gone.
-#include "llinventoryfilter.h"
-#include "llinventoryfunctions.h"
-#include "llinventorymodelbackgroundfetch.h"
 #include "llinventorypanel.h"
 #include "llfoldertype.h"
-#include "llfloaterinventory.h"// hacked in for the bonus context menu items.
 #include "llkeyboard.h"
 #include "lllineeditor.h"
 #include "llmenugl.h"
@@ -65,7 +61,6 @@
 #include "llfontgl.h"
 #include "llgl.h" 
 #include "llrender.h"
-#include "llinventory.h"
 
 // Third-party library includes
 #include <algorithm>
@@ -141,7 +136,7 @@ const LLRect LLFolderViewScrollContainer::getScrolledViewRect() const
 		LLFolderView* folder_view = dynamic_cast<LLFolderView*>(mScrolledView);
 		if (folder_view)
 		{
-			S32 height = folder_view->mRunningHeight;
+			S32 height = folder_view->getRect().getHeight();
 
 			rect = mScrolledView->getRect();
 			rect.setLeftTopAndSize(rect.mLeft, rect.mTop, rect.getWidth(), height);
@@ -188,7 +183,7 @@ LLFolderView::LLFolderView(const Params& p)
 	mNeedsAutoRename(FALSE),
 	mDebugFilters(FALSE),
 	mSortOrder(LLInventoryFilter::SO_FOLDERS_BY_NAME),	// This gets overridden by a pref immediately
-	mFilter( new LLInventoryFilter(p.title) ),
+	mFilter(),
 	mShowSelectionContext(FALSE),
 	mShowSingleSelection(FALSE),
 	mArrangeGeneration(0),
@@ -304,7 +299,7 @@ BOOL LLFolderView::canFocusChildren() const
 BOOL LLFolderView::addFolder( LLFolderViewFolder* folder)
 {
 	// enforce sort order of My Inventory followed by Library
-	if (folder->getViewModelItem()->getUUID() == gInventory.getLibraryRootFolderID())
+	if (((LLFolderViewModelItemInventory*)folder->getViewModelItem())->getUUID() == gInventory.getLibraryRootFolderID())
 	{
 		mFolders.push_back(folder);
 	}
@@ -364,7 +359,7 @@ S32 LLFolderView::arrange( S32* unused_width, S32* unused_height, S32 filter_gen
 	return llround(mTargetHeight);
 }
 
-static LLFastTimer::DeclareTimer FTM_FILTER("Filter Inventory");
+static LLFastTimer::DeclareTimer FTM_FILTER("Filter Folder View");
 
 void LLFolderView::filter( LLFolderViewFilter& filter )
 {
@@ -392,7 +387,7 @@ void LLFolderView::reshape(S32 width, S32 height, BOOL called_from_parent)
 		scroll_rect = mScrollContainer->getContentWindowRect();
 	}
 	width = llmax(mMinWidth, scroll_rect.getWidth());
-	height = llmax(mCurHeight, scroll_rect.getHeight());
+	height = llmax(llround(mCurHeight), scroll_rect.getHeight());
 
 	// Restrict width within scroll container's width
 	if (mUseEllipses && mScrollContainer)
@@ -645,7 +640,6 @@ void LLFolderView::clearSelection()
 	}
 
 	mSelectedItems.clear();
-	mSelectThisID.setNull();
 }
 
 std::set<LLFolderViewItem*> LLFolderView::getSelectionList() const
@@ -735,9 +729,9 @@ void LLFolderView::draw()
 	}
 	else if (mShowEmptyMessage)
 	{
-		if (LLInventoryModelBackgroundFetch::instance().folderFetchActive() || mCompletedFilterGeneration < mFilter->getFirstSuccessGeneration())
+		if (!mViewModel->contentsReady() || mCompletedFilterGeneration < mFilter->getFirstSuccessGeneration())
 		{
-			RN: Get this from filter
+			// TODO RN: Get this from filter
 			mStatusText = LLTrans::getString("Searching");
 		}
 		else
@@ -921,7 +915,7 @@ void LLFolderView::onItemsRemovalConfirmation(const LLSD& notification, const LL
 		else if (count > 1)
 		{
 			LLDynamicArray<LLFolderViewModelItem*> listeners;
-			LLFolderViewModelItemInventory* listener;
+			LLFolderViewModelItem* listener;
 			LLFolderViewItem* last_item = items[count - 1];
 			LLFolderViewItem* new_selection = last_item->getNextOpenNode(FALSE);
 			while(new_selection && new_selection->isSelected())
@@ -948,12 +942,12 @@ void LLFolderView::onItemsRemovalConfirmation(const LLSD& notification, const LL
 			for(S32 i = 0; i < count; ++i)
 			{
 				listener = items[i]->getViewModelItem();
-				if(listener && (listeners.find(listener) == LLDynamicArray<LLFolderViewModelItemInventory*>::FAIL))
+				if(listener && (listeners.find(listener) == LLDynamicArray<LLFolderViewModelItem*>::FAIL))
 				{
 					listeners.put(listener);
 				}
 			}
-			listener = static_cast<LLFolderViewModelItemInventory*>(listeners.get(0));
+			listener = static_cast<LLFolderViewModelItem*>(listeners.get(0));
 			if(listener)
 			{
 				listener->removeBatch(listeners);
@@ -969,36 +963,37 @@ void LLFolderView::openSelectedItems( void )
 {
 	if(getVisible() && getEnabled())
 	{
-		if (mSelectedItems.size() == 1)
-		{
-			mSelectedItems.front()->openItem();
-		}
-		else
-		{
-			LLMultiPreview* multi_previewp = new LLMultiPreview();
-			LLMultiProperties* multi_propertiesp = new LLMultiProperties();
-
-			selected_items_t::iterator item_it;
-			for (item_it = mSelectedItems.begin(); item_it != mSelectedItems.end(); ++item_it)
-			{
-				// IT_{OBJECT,ATTACHMENT} creates LLProperties
-				// floaters; others create LLPreviews.  Put
-				// each one in the right type of container.
-				LLFolderViewModelItemInventory* listener = (*item_it)->getViewModelItem();
-				bool is_prop = listener && (listener->getInventoryType() == LLInventoryType::IT_OBJECT || listener->getInventoryType() == LLInventoryType::IT_ATTACHMENT);
-				if (is_prop)
-					LLFloater::setFloaterHost(multi_propertiesp);
-				else
-					LLFloater::setFloaterHost(multi_previewp);
-				(*item_it)->openItem();
-			}
-
-			LLFloater::setFloaterHost(NULL);
-			// *NOTE: LLMulti* will safely auto-delete when open'd
-			// without any children.
-			multi_previewp->openFloater(LLSD());
-			multi_propertiesp->openFloater(LLSD());
-		}
+		// TODO RN: move to LLFolderViewModelInventory
+		//if (mSelectedItems.size() == 1)
+		//{
+		//	mSelectedItems.front()->openItem();
+		//}
+		//else
+		//{
+		//	LLMultiPreview* multi_previewp = new LLMultiPreview();
+		//	LLMultiProperties* multi_propertiesp = new LLMultiProperties();
+
+		//	selected_items_t::iterator item_it;
+		//	for (item_it = mSelectedItems.begin(); item_it != mSelectedItems.end(); ++item_it)
+		//	{
+		//		// IT_{OBJECT,ATTACHMENT} creates LLProperties
+		//		// floaters; others create LLPreviews.  Put
+		//		// each one in the right type of container.
+		//		LLFolderViewModelItemInventory* listener = (*item_it)->getViewModelItem();
+		//		bool is_prop = listener && (listener->getInventoryType() == LLInventoryType::IT_OBJECT || listener->getInventoryType() == LLInventoryType::IT_ATTACHMENT);
+		//		if (is_prop)
+		//			LLFloater::setFloaterHost(multi_propertiesp);
+		//		else
+		//			LLFloater::setFloaterHost(multi_previewp);
+		//		(*item_it)->openItem();
+		//	}
+
+		//	LLFloater::setFloaterHost(NULL);
+		//	// *NOTE: LLMulti* will safely auto-delete when open'd
+		//	// without any children.
+		//	multi_previewp->openFloater(LLSD());
+		//	multi_propertiesp->openFloater(LLSD());
+		//}
 	}
 }
 
@@ -1006,27 +1001,28 @@ void LLFolderView::propertiesSelectedItems( void )
 {
 	if(getVisible() && getEnabled())
 	{
-		if (mSelectedItems.size() == 1)
-		{
-			LLFolderViewItem* folder_item = mSelectedItems.front();
-			if(!folder_item) return;
-			folder_item->getViewModelItem()->showProperties();
-		}
-		else
-		{
-			LLMultiProperties* multi_propertiesp = new LLMultiProperties();
+		// TODO RN: move to LLFolderViewModelInventory
+		//if (mSelectedItems.size() == 1)
+		//{
+		//	LLFolderViewItem* folder_item = mSelectedItems.front();
+		//	if(!folder_item) return;
+		//	folder_item->getViewModelItem()->showProperties();
+		//}
+		//else
+		//{
+		//	LLMultiProperties* multi_propertiesp = new LLMultiProperties();
 
-			LLFloater::setFloaterHost(multi_propertiesp);
+		//	LLFloater::setFloaterHost(multi_propertiesp);
 
-			selected_items_t::iterator item_it;
-			for (item_it = mSelectedItems.begin(); item_it != mSelectedItems.end(); ++item_it)
-			{
-				(*item_it)->getViewModelItem()->showProperties();
-			}
+		//	selected_items_t::iterator item_it;
+		//	for (item_it = mSelectedItems.begin(); item_it != mSelectedItems.end(); ++item_it)
+		//	{
+		//		(*item_it)->getViewModelItem()->showProperties();
+		//	}
 
-			LLFloater::setFloaterHost(NULL);
-			multi_propertiesp->openFloater(LLSD());
-		}
+		//	LLFloater::setFloaterHost(NULL);
+		//	multi_propertiesp->openFloater(LLSD());
+		//}
 	}
 }
 
@@ -1140,7 +1136,7 @@ void LLFolderView::copy()
 	S32 count = mSelectedItems.size();
 	if(getVisible() && getEnabled() && (count > 0))
 	{
-		LLFolderViewModelItemInventory* listener = NULL;
+		LLFolderViewModelItem* listener = NULL;
 		selected_items_t::iterator item_it;
 		for (item_it = mSelectedItems.begin(); item_it != mSelectedItems.end(); ++item_it)
 		{
@@ -1164,7 +1160,7 @@ BOOL LLFolderView::canCut() const
 	for (selected_items_t::const_iterator selected_it = mSelectedItems.begin(); selected_it != mSelectedItems.end(); ++selected_it)
 	{
 		const LLFolderViewItem* item = *selected_it;
-		const LLFolderViewModelItemInventory* listener = item->getViewModelItem();
+		const LLFolderViewModelItem* listener = item->getViewModelItem();
 
 		if (!listener || !listener->isItemRemovable())
 		{
@@ -1181,7 +1177,7 @@ void LLFolderView::cut()
 	S32 count = mSelectedItems.size();
 	if(getVisible() && getEnabled() && (count > 0))
 	{
-		LLFolderViewModelItemInventory* listener = NULL;
+		LLFolderViewModelItem* listener = NULL;
 		selected_items_t::iterator item_it;
 		for (item_it = mSelectedItems.begin(); item_it != mSelectedItems.end(); ++item_it)
 		{
@@ -1210,7 +1206,7 @@ BOOL LLFolderView::canPaste() const
 		{
 			// *TODO: only check folders and parent folders of items
 			const LLFolderViewItem* item = (*item_it);
-			const LLFolderViewModelItemInventory* listener = item->getViewModelItem();
+			const LLFolderViewModelItem* listener = item->getViewModelItem();
 			if(!listener || !listener->isClipboardPasteable())
 			{
 				const LLFolderViewFolder* folderp = item->getParentFolder();
@@ -1232,24 +1228,24 @@ void LLFolderView::paste()
 	if(getVisible() && getEnabled())
 	{
 		// find set of unique folders to paste into
-		std::set<LLFolderViewItem*> folder_set;
+		std::set<LLFolderViewFolder*> folder_set;
 
 		selected_items_t::iterator selected_it;
 		for (selected_it = mSelectedItems.begin(); selected_it != mSelectedItems.end(); ++selected_it)
 		{
 			LLFolderViewItem* item = *selected_it;
-			LLFolderViewModelItemInventory* listener = item->getViewModelItem();
-			if (listener->getInventoryType() != LLInventoryType::IT_CATEGORY)
+			LLFolderViewFolder* folder = dynamic_cast<LLFolderViewFolder*>(item);
+			if (folder == NULL)
 			{
 				item = item->getParentFolder();
 			}
-			folder_set.insert(item);
+			folder_set.insert(folder);
 		}
 
-		std::set<LLFolderViewItem*>::iterator set_iter;
+		std::set<LLFolderViewFolder*>::iterator set_iter;
 		for(set_iter = folder_set.begin(); set_iter != folder_set.end(); ++set_iter)
 		{
-			LLFolderViewModelItemInventory* listener = (*set_iter)->getListener();
+			LLFolderViewModelItem* listener = (*set_iter)->getViewModelItem();
 			if(listener && listener->isClipboardPasteable())
 			{
 				listener->pasteFromClipboard();
@@ -1765,15 +1761,9 @@ BOOL LLFolderView::handleDragAndDrop(S32 x, S32 y, MASK mask, BOOL drop,
 
 	// when drop is not handled by child, it should be handled
 	// by the folder which is the hierarchy root.
-	if (!handled
-		&& getViewModelItem()->getUUID().notNull())
-		{
-			handled = LLFolderViewFolder::handleDragAndDrop(x, y, mask, drop, cargo_type, cargo_data, accept, tooltip_msg);
-		}
-
-	if (handled)
+	if (!handled)
 	{
-		lldebugst(LLERR_USER_INPUT) << "dragAndDrop handled by LLFolderView" << llendl;
+		handled = LLFolderViewFolder::handleDragAndDrop(x, y, mask, drop, cargo_type, cargo_data, accept, tooltip_msg);
 	}
 
 	return handled;
@@ -1996,7 +1986,7 @@ void LLFolderView::doIdle()
 
 		// Open filtered folders for folder views with mAutoSelectOverride=TRUE.
 		// Used by LLPlacesFolderView.
-		if (mAutoSelectOverride && !mFilter->getFilterSubString().empty())
+		if (mAutoSelectOverride && mFilter->showAllResults())
 		{
 			// these are named variables to get around gcc not binding non-const references to rvalues
 			// and functor application is inherently non-const to allow for stateful functors
@@ -2008,7 +1998,7 @@ void LLFolderView::doIdle()
 	}
 
 	BOOL filter_finished = mCompletedFilterGeneration >= mFilter->getCurrentGeneration() 
-						&& !LLInventoryModelBackgroundFetch::instance().folderFetchActive();
+						&& mViewModel->contentsReady();
 	if (filter_finished 
 		|| gFocusMgr.childHasKeyboardFocus(inventory_panel) 
 		|| gFocusMgr.childHasMouseCapture(inventory_panel))
diff --git a/indra/newview/llfolderview.h b/indra/newview/llfolderview.h
index 9b8a629387..813b4d130f 100644
--- a/indra/newview/llfolderview.h
+++ b/indra/newview/llfolderview.h
@@ -337,6 +337,67 @@ public:
 
 };
 
+
+//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+// Class LLFolderViewFunctor
+//
+// Simple abstract base class for applying a functor to folders and
+// items in a folder view hierarchy. This is suboptimal for algorithms
+// that only work folders or only work on items, but I'll worry about
+// that later when it's determined to be too slow.
+//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+class LLFolderViewFunctor
+{
+public:
+	virtual ~LLFolderViewFunctor() {}
+	virtual void doFolder(LLFolderViewFolder* folder) = 0;
+	virtual void doItem(LLFolderViewItem* item) = 0;
+};
+
+class LLSelectFirstFilteredItem : public LLFolderViewFunctor
+{
+public:
+	LLSelectFirstFilteredItem() : mItemSelected(FALSE) {}
+	virtual ~LLSelectFirstFilteredItem() {}
+	virtual void doFolder(LLFolderViewFolder* folder);
+	virtual void doItem(LLFolderViewItem* item);
+	BOOL wasItemSelected() { return mItemSelected; }
+protected:
+	BOOL mItemSelected;
+};
+
+class LLOpenFilteredFolders : public LLFolderViewFunctor
+{
+public:
+	LLOpenFilteredFolders()  {}
+	virtual ~LLOpenFilteredFolders() {}
+	virtual void doFolder(LLFolderViewFolder* folder);
+	virtual void doItem(LLFolderViewItem* item);
+};
+
+class LLSaveFolderState : public LLFolderViewFunctor
+{
+public:
+	LLSaveFolderState() : mApply(FALSE) {}
+	virtual ~LLSaveFolderState() {}
+	virtual void doFolder(LLFolderViewFolder* folder);
+	virtual void doItem(LLFolderViewItem* item) {}
+	void setApply(BOOL apply);
+	void clearOpenFolders() { mOpenFolders.clear(); }
+protected:
+	std::set<LLUUID> mOpenFolders;
+	BOOL mApply;
+};
+
+class LLOpenFoldersWithSelection : public LLFolderViewFunctor
+{
+public:
+	LLOpenFoldersWithSelection() {}
+	virtual ~LLOpenFoldersWithSelection() {}
+	virtual void doFolder(LLFolderViewFolder* folder);
+	virtual void doItem(LLFolderViewItem* item);
+};
+
 // Flags for buildContextMenu()
 const U32 SUPPRESS_OPEN_ITEM = 0x1;
 const U32 FIRST_SELECTED_ITEM = 0x2;
diff --git a/indra/newview/llfolderviewitem.cpp b/indra/newview/llfolderviewitem.cpp
index 0a3c03e868..6e60ec5e1a 100644
--- a/indra/newview/llfolderviewitem.cpp
+++ b/indra/newview/llfolderviewitem.cpp
@@ -2529,7 +2529,7 @@ LLFolderViewItem* LLFolderViewFolder::getPreviousFromChild( LLFolderViewItem* it
 	return result;
 }
 
-bool LLInventorySort::operator()(const LLFolderViewModelItemInventory* const& a, const LLFolderViewModelItemInventory* const& b)
+bool LLInventorySort::operator()(const LLFolderViewModelItemInventory* const& a, const LLFolderViewModelItemInventory* const& b) const
 {
 	// ignore sort order for landmarks in the Favorites folder.
 	// they should be always sorted as in Favorites bar. See EXT-719
diff --git a/indra/newview/llfolderviewitem.h b/indra/newview/llfolderviewitem.h
index 7bcc9dd0a2..9e024d7eea 100644
--- a/indra/newview/llfolderviewitem.h
+++ b/indra/newview/llfolderviewitem.h
@@ -475,6 +475,11 @@ public:
 
 	LLFolderViewFolder* getCommonAncestor(LLFolderViewItem* item_a, LLFolderViewItem* item_b, bool& reverse);
 	void gatherChildRangeExclusive(LLFolderViewItem* start, LLFolderViewItem* end, bool reverse,  std::vector<LLFolderViewItem*>& items);
+
+public:
+	//WARNING: do not call directly...use the appropriate LLFolderViewModel-derived class instead
+	template<typename SORT_FUNC> void sortFolders(SORT_FUNC& func) { mFolders.sort(func); }
+	template<typename SORT_FUNC> void sortItems(SORT_FUNC& func) { mItems.sort(func); }
 };
 
 
diff --git a/indra/newview/llfolderviewmodel.h b/indra/newview/llfolderviewmodel.h
index b81a81f837..9bbd7f48cf 100644
--- a/indra/newview/llfolderviewmodel.h
+++ b/indra/newview/llfolderviewmodel.h
@@ -56,7 +56,7 @@ class LLFolderViewFolder;
 class LLFolderViewFilter
 {
 public:
-	enum EFilterBehavior
+	enum EFilterModified
 	{
 		FILTER_NONE,				// nothing to do, already filtered
 		FILTER_RESTART,				// restart filtering from scratch
@@ -78,7 +78,7 @@ public:
 	virtual bool				checkFolder(const LLUUID& folder_id) const = 0;
 
 	virtual void 				setEmptyLookupMessage(const std::string& message) = 0;
-	const virtual std::string&	getEmptyLookupMessage() const = 0;
+	virtual std::string			getEmptyLookupMessage() const = 0;
 
 	virtual bool				showAllResults() const = 0;
 
@@ -87,12 +87,11 @@ public:
 	// +-------------------------------------------------------------------+
 	virtual bool 				isActive() const = 0;
 	virtual bool 				isModified() const = 0;
-	virtual bool 				isModifiedAndClear() = 0;
 	virtual void 				clearModified() = 0;
 	virtual const std::string& 	getName() const = 0;
 	virtual const std::string& 	getFilterText() = 0;
 	//RN: this is public to allow system to externally force a global refilter
-	virtual void 				setModified(EFilterBehavior behavior = FILTER_RESTART) = 0;
+	virtual void 				setModified(EFilterModified behavior = FILTER_RESTART) = 0;
 
 	// +-------------------------------------------------------------------+
 	// + Count
@@ -125,6 +124,8 @@ public:
 
 	virtual void sort(class LLFolderViewFolder*) = 0;
 	virtual void filter(class LLFolderViewFolder*) = 0;
+
+	virtual bool contentsReady() = 0;
 };
 
 struct LLFolderViewModelCommon : public LLFolderViewModelInterface
@@ -230,7 +231,7 @@ protected:
 template <typename SORT_TYPE, typename ITEM_TYPE, typename FOLDER_TYPE, typename FILTER_TYPE>
 class LLFolderViewModel : public LLFolderViewModelCommon
 {
-protected:
+public:
 	LLFolderViewModel() {}
 	virtual ~LLFolderViewModel() {}
 	
@@ -239,12 +240,14 @@ protected:
 	typedef FOLDER_TYPE		FolderType;
 	typedef FILTER_TYPE		FilterType;
 	
+	virtual SortType& getSorter()					 { return mSorter; }
 	virtual const SortType& getSorter() const 		 { return mSorter; }
 	virtual void setSorter(const SortType& sorter) 	 { mSorter = sorter; requestSortAll(); }
-	virtual FilterType& getFilter()					 { return mFilter; }
+	virtual FilterType& getFilter() 				 { return mFilter; }
+	virtual const FilterType& getFilter() const		 { return mFilter; }
 	virtual void setFilter(const FilterType& filter) { mFilter = filter; }
 
-public:
+	virtual bool contentsReady()					{ return true; }
 
 	struct ViewModelCompare
 	{
@@ -252,12 +255,12 @@ public:
 		:	mSorter(sorter)
 		{}
 		
-		int operator () (const LLFolderViewItem* a, const LLFolderViewItem* b)
+		bool operator () (const LLFolderViewItem* a, const LLFolderViewItem* b)
 		{
 			return mSorter(static_cast<const ItemType*>(a->getViewModelItem()), static_cast<const ItemType*>(b->getViewModelItem()));
 		}
 
-		int operator () (const LLFolderViewFolder* a, const LLFolderViewFolder* b)
+		bool operator () (const LLFolderViewFolder* a, const LLFolderViewFolder* b)
 		{
 			return mSorter(static_cast<const ItemType*>(a->getViewModelItem()), static_cast<const ItemType*>(b->getViewModelItem()));
 		}
@@ -269,8 +272,8 @@ public:
 	{
 		if (needsSort(folder->getViewModelItem()))
 		{
-			std::sort(folder->getFoldersBegin(), folder->getFoldersEnd(), ViewModelCompare(getSorter()));
-			std::sort(folder->getItemsBegin(), folder->getItemsEnd(), ViewModelCompare(getSorter()));
+			folder->sortFolders(ViewModelCompare(getSorter()));
+			folder->sortItems(ViewModelCompare(getSorter()));
 			folder->getViewModelItem()->setSortVersion(mTargetSortVersion);
 			folder->requestArrange();
 		}
diff --git a/indra/newview/llinventorybridge.cpp b/indra/newview/llinventorybridge.cpp
index b51bbf7bfe..312b7314a1 100644
--- a/indra/newview/llinventorybridge.cpp
+++ b/indra/newview/llinventorybridge.cpp
@@ -423,7 +423,7 @@ void  LLInvFVBridge::removeBatchNoCheck(std::vector<LLFolderViewModelItem*>&  ba
 
 	for(i = 0; i < count; ++i)
 	{
-		bridge = (LLInvFVBridge*)(batch.get(i));
+		bridge = (LLInvFVBridge*)(batch[i]);
 		if(!bridge || !bridge->isItemRemovable()) continue;
 		LLViewerInventoryCategory* cat = (LLViewerInventoryCategory*)model->getCategory(bridge->getUUID());
 		if(cat)
@@ -1275,7 +1275,7 @@ bool LLInvFVBridge::canListOnMarketplaceNow() const
 
 		if (can_list)
 		{
-			LLFolderViewFolder * object_folderp =   mInventoryPanel->getFolderByID(object_id);
+			LLFolderViewFolder * object_folderp =   mInventoryPanel.get() ? mInventoryPanel.get()->getFolderByID(object_id) : NULL;
 			if (object_folderp)
 			{
 				can_list = !object_folderp->isLoading();
@@ -1286,7 +1286,7 @@ bool LLInvFVBridge::canListOnMarketplaceNow() const
 		{
 			// Get outbox id
 			const LLUUID & outbox_id = getInventoryModel()->findCategoryUUIDForType(LLFolderType::FT_OUTBOX, false);
-			LLFolderViewItem * outbox_itemp =   mInventoryPanel->getItemByID(outbox_id);
+			LLFolderViewItem * outbox_itemp =   mInventoryPanel.get() ? mInventoryPanel.get()->getItemByID(outbox_id) : NULL;
 
 			if (outbox_itemp)
 			{
diff --git a/indra/newview/llinventoryfilter.cpp b/indra/newview/llinventoryfilter.cpp
index 1d25a7a1f9..9c9b04d03d 100644
--- a/indra/newview/llinventoryfilter.cpp
+++ b/indra/newview/llinventoryfilter.cpp
@@ -42,6 +42,8 @@
 #include "llclipboard.h"
 #include "lltrans.h"
 
+//TODO RN: fix use of static cast as much as possible
+
 LLFastTimer::DeclareTimer FT_FILTER_CLIPBOARD("Filter Clipboard");
 
 LLInventoryFilter::FilterOps::FilterOps(const Params& p)
@@ -62,37 +64,27 @@ LLInventoryFilter::FilterOps::FilterOps(const Params& p)
 ///----------------------------------------------------------------------------
 /// Class LLInventoryFilter
 ///----------------------------------------------------------------------------
-LLInventoryFilter::LLInventoryFilter(const std::string& name, const   Params& p)
-:	mName(name),
-	mModified(FALSE),
-	mNeedTextRebuild(TRUE),
+LLInventoryFilter::LLInventoryFilter(const Params& p)
+:	mFilterModified(FILTER_NONE),
 	mEmptyLookupMessage("InventoryNoMatchingItems"),
-        mFilterOps(p.filter_ops)
+    mFilterOps(p.filter_ops),
+	mOrder(p.sort_order),
+	mFilterSubString(p.substring),
+	mLastSuccessGeneration(0),
+	mLastFailGeneration(S32_MAX),
+	mFirstSuccessGeneration(0),
+	mFilterCount(0)
 {
-	mOrder = p.sort_order; // This gets overridden by a pref immediately
-
-	mFilterSubString(p.substring);
-	mLastSuccessGeneration = 0;
-	mLastFailGeneration = S32_MAX;
-	getFirstSuccessGeneration = 0;
-	mFilterCount = 0;
 	mNextFilterGeneration = mLastSuccessGeneration + 1;
 
-	mLastLogoff = gSavedPerAccountSettings.getU32("LastLogoff");
-	mFilterBehavior = FILTER_NONE;
-
 	// copy mFilterOps into mDefaultFilterOps
 	markDefault();
 }
 
-LLInventoryFilter::~LLInventoryFilter()
-{
-}
-
-BOOL LLInventoryFilter::check(const LLFolderViewItem* item) 
+bool LLInventoryFilter::check(const LLFolderViewItem* item) 
 {
 	// Clipboard cut items are *always* filtered so we need this value upfront
-	const LLFolderViewEventListener* listener = item->getViewModelItem();
+	const LLFolderViewModelItemInventory* listener = static_cast<const LLFolderViewModelItemInventory*>(item->getViewModelItem());
 	const BOOL passed_clipboard = (listener ? checkAgainstClipboard(listener->getUUID()) : TRUE);
 
 	// If it's a folder and we're showing all folders, return automatically.
@@ -140,7 +132,7 @@ bool LLInventoryFilter::checkFolder(const LLFolderViewFolder* folder) const
 		return false;
 	}
 
-	const LLFolderViewModelItemInventory* listener = folder->getViewModelItem();
+	const LLFolderViewModelItemInventory* listener = static_cast<const LLFolderViewModelItemInventory*>(folder->getViewModelItem());
 	if (!listener)
 	{
 		llwarns << "Folder view event listener not found." << llendl;
@@ -157,9 +149,9 @@ bool LLInventoryFilter::checkFolder(const LLUUID& folder_id) const
 {
 	// when applying a filter, matching folders get their contents downloaded first
 	if (isNotDefault()
-		&& !gInventory.isCategoryComplete(getUUID())))
+		&& !gInventory.isCategoryComplete(folder_id))
 	{
-		LLInventoryModelBackgroundFetch::instance().start(getViewModelItem()->getUUID());
+		LLInventoryModelBackgroundFetch::instance().start(folder_id);
 	}
 
 	// Always check against the clipboard
@@ -186,9 +178,9 @@ bool LLInventoryFilter::checkFolder(const LLUUID& folder_id) const
 	return passed_clipboard;
 }
 
-BOOL LLInventoryFilter::checkAgainstFilterType(const LLFolderViewItem* item) const
+bool LLInventoryFilter::checkAgainstFilterType(const LLFolderViewItem* item) const
 {
-	const LLFolderViewModelItemInventory* listener = item->getViewModelItem();
+	const LLFolderViewModelItemInventory* listener = static_cast<const LLFolderViewModelItemInventory*>(item->getViewModelItem());
 	if (!listener) return FALSE;
 
 	LLInventoryType::EType object_type = listener->getInventoryType();
@@ -354,9 +346,9 @@ bool LLInventoryFilter::checkAgainstClipboard(const LLUUID& object_id) const
 	return true;
 }
 
-BOOL LLInventoryFilter::checkAgainstPermissions(const LLFolderViewItem* item) const
+bool LLInventoryFilter::checkAgainstPermissions(const LLFolderViewItem* item) const
 {
-	const LLFolderViewModelItemInventory* listener = item->getViewModelItem();
+	const LLFolderViewModelItemInventory* listener = static_cast<const LLFolderViewModelItemInventory*>(item->getViewModelItem());
 	if (!listener) return FALSE;
 
 	PermissionMask perm = listener->getPermissionMask();
@@ -382,9 +374,9 @@ bool LLInventoryFilter::checkAgainstPermissions(const LLInventoryItem* item) con
 	return (perm & mFilterOps.mPermissions) == mFilterOps.mPermissions;
 }
 
-BOOL LLInventoryFilter::checkAgainstFilterLinks(const LLFolderViewItem* item) const
+bool LLInventoryFilter::checkAgainstFilterLinks(const LLFolderViewItem* item) const
 {
-	const LLFolderViewModelItemInventory* listener = item->getViewModelItem();
+	const LLFolderViewModelItemInventory* listener = static_cast<const LLFolderViewModelItemInventory*>(item->getViewModelItem());
 	if (!listener) return TRUE;
 
 	const LLUUID object_id = listener->getUUID();
@@ -409,7 +401,7 @@ std::string::size_type   LLInventoryFilter::getStringMatchOffset(LLFolderViewIte
 	return mFilterSubString.size() ? item->getName().find(mFilterSubString)   : std::string::npos;
 }
 
-BOOL LLInventoryFilter::isDefault() const
+bool LLInventoryFilter::isDefault() const
 {
 	return !isNotDefault();
 }
@@ -417,7 +409,7 @@ BOOL LLInventoryFilter::isDefault() const
 // has user modified default filter params?
 bool LLInventoryFilter::isNotDefault() const
 {
-	bool not_default = FALSE;
+	S32 not_default = 0;
 
 	not_default |= (mFilterOps.mFilterObjectTypes != mDefaultFilterOps.mFilterObjectTypes);
 	not_default |= (mFilterOps.mFilterCategoryTypes != mDefaultFilterOps.mFilterCategoryTypes);
@@ -430,10 +422,10 @@ bool LLInventoryFilter::isNotDefault() const
 	not_default |= (mFilterOps.mMaxDate != mDefaultFilterOps.mMaxDate);
 	not_default |= (mFilterOps.mHoursAgo != mDefaultFilterOps.mHoursAgo);
 
-	return not_default;
+	return not_default != 0;
 }
 
-BOOL LLInventoryFilter::isActive() const
+bool LLInventoryFilter::isActive() const
 {
 	return mFilterOps.mFilterObjectTypes != 0xffffffffffffffffULL
 		|| mFilterOps.mFilterCategoryTypes != 0xffffffffffffffffULL
@@ -447,16 +439,9 @@ BOOL LLInventoryFilter::isActive() const
 		|| mFilterOps.mHoursAgo != 0;
 }
 
-BOOL LLInventoryFilter::isModified() const
-{
-	return mModified;
-}
-
-BOOL LLInventoryFilter::isModifiedAndClear()
+bool LLInventoryFilter::isModified() const
 {
-	BOOL ret = mModified;
-	mModified = FALSE;
-	return ret;
+	return mFilterModified != FILTER_NONE;
 }
 
 void LLInventoryFilter::updateFilterTypes(U64 types, U64& current_types)
@@ -620,9 +605,10 @@ void LLInventoryFilter::setDateRange(time_t min_date, time_t max_date)
 
 void LLInventoryFilter::setDateRangeLastLogoff(BOOL sl)
 {
+	static LLCachedControl<U32> s_last_logoff(gSavedSettings, "LastLogoff", 0);
 	if (sl && !isSinceLogoff())
 	{
-		setDateRange(mLastLogoff, time_max());
+		setDateRange(s_last_logoff(), time_max());
 		setModified();
 	}
 	if (!sl && isSinceLogoff())
@@ -641,17 +627,18 @@ void LLInventoryFilter::setDateRangeLastLogoff(BOOL sl)
 	}
 }
 
-BOOL LLInventoryFilter::isSinceLogoff() const
+bool LLInventoryFilter::isSinceLogoff() const
 {
-	return (mFilterOps.mMinDate == (time_t)mLastLogoff) &&
+	static LLCachedControl<U32> s_last_logoff(gSavedSettings, "LastLogoff", 0);
+
+	return (mFilterOps.mMinDate == (time_t)s_last_logoff()) &&
 		(mFilterOps.mMaxDate == time_max()) &&
 		(mFilterOps.mFilterTypes & FILTERTYPE_DATE);
 }
 
 void LLInventoryFilter::clearModified()
 {
-	mModified = FALSE; 
-	mFilterBehavior = FILTER_NONE;
+	mFilterModified = FILTER_NONE;
 }
 
 void LLInventoryFilter::setHoursAgo(U32 hours)
@@ -749,27 +736,26 @@ void LLInventoryFilter::resetDefault()
 	setModified();
 }
 
-void LLInventoryFilter::setModified(EFilterBehavior behavior)
+void LLInventoryFilter::setModified(EFilterModified behavior)
 {
-	mModified = TRUE;
-	mNeedTextRebuild = TRUE;
+	mFilterText.clear();
 	mLastSuccessGeneration = mNextFilterGeneration++;
 
-	if (mFilterBehavior == FILTER_NONE)
+	if (mFilterModified == FILTER_NONE)
 	{
-		mFilterBehavior = behavior;
+		mFilterModified = behavior;
 	}
-	else if (mFilterBehavior != behavior)
+	else if (mFilterModified != behavior)
 	{
 		// trying to do both less restrictive and more restrictive filter
 		// basically means restart from scratch
-		mFilterBehavior = FILTER_RESTART;
+		mFilterModified = FILTER_RESTART;
 	}
 
 	if (isNotDefault())
 	{
 		// if not keeping current filter results, update last valid as well
-		switch(mFilterBehavior)
+		switch(mFilterModified)
 		{
 			case FILTER_RESTART:
 				mLastFailGeneration = mLastSuccessGeneration;
@@ -791,29 +777,29 @@ void LLInventoryFilter::setModified(EFilterBehavior behavior)
 	else
 	{
 		// shortcut disabled filters to show everything immediately
-		mMinRequiredGeneration = 0;
-		mMustPassGeneration = S32_MAX;
+		mLastFailGeneration = 0;
+		mFirstSuccessGeneration = S32_MAX;
 	}
 }
 
-BOOL LLInventoryFilter::isFilterObjectTypesWith(LLInventoryType::EType t) const
+bool LLInventoryFilter::isFilterObjectTypesWith(LLInventoryType::EType t) const
 {
 	return mFilterOps.mFilterObjectTypes & (1LL << t);
 }
 
 const std::string& LLInventoryFilter::getFilterText()
 {
-	if (!mNeedTextRebuild)
+	if (!mFilterText.empty())
 	{
 		return mFilterText;
 	}
 
-	mNeedTextRebuild = FALSE;
 	std::string filtered_types;
 	std::string not_filtered_types;
 	BOOL filtered_by_type = FALSE;
 	BOOL filtered_by_all_types = TRUE;
 	S32 num_filter_types = 0;
+
 	mFilterText.clear();
 
 	if (isFilterObjectTypesWith(LLInventoryType::IT_ANIMATION))
@@ -998,9 +984,26 @@ const std::string& LLInventoryFilter::getFilterText()
 	return mFilterText;
 }
 
+
+LLInventoryFilter& LLInventoryFilter::operator=( const  LLInventoryFilter&  other )
+{
+	setFilterObjectTypes(other.getFilterObjectTypes());
+	setDateRange(other.getMinDate(), other.getMaxDate());
+	setHoursAgo(other.getHoursAgo());
+	setShowFolderState(other.getShowFolderState());
+	setFilterPermissions(other.getFilterPermissions());
+	setFilterSubString(other.getFilterSubString());
+	setSortOrder(other.getSortOrder());
+	setDateRangeLastLogoff(other.isSinceLogoff());
+	return *this;
+}
+
+
 void LLInventoryFilter::toParams(Params& params) const
-	{
+{
 	params.filter_ops.types = getFilterObjectTypes();
+	params.filter_ops.category_types = getFilterCategoryTypes();
+	params.filter_ops.wearable_types = getFilterWearableTypes();
 	params.filter_ops.date_range.min_date = getMinDate();
 	params.filter_ops.date_range.max_date = getMaxDate();
 	params.filter_ops.hours_ago = getHoursAgo();
@@ -1009,16 +1012,18 @@ void LLInventoryFilter::toParams(Params& params) const
 	params.substring = getFilterSubString();
 	params.sort_order = getSortOrder();
 	params.since_logoff = isSinceLogoff();
-	}
+}
 
-void LLInventoryFilter::fromParams(const Params& data)
-	{
+void LLInventoryFilter::fromParams(const Params& params)
+{
 	if (!params.validateBlock())
 	{
 		return;
 	}
 
 	setFilterObjectTypes(params.filter_ops.types);
+	setFilterCategoryTypes(params.filter_ops.category_types);
+	setFilterWearableTypes(params.filter_ops.wearable_types);
 	setDateRange(params.filter_ops.date_range.min_date,   params.filter_ops.date_range.max_date);
 	setHoursAgo(params.filter_ops.hours_ago);
 	setShowFolderState(params.filter_ops.show_folder_state);
@@ -1038,7 +1043,12 @@ U64 LLInventoryFilter::getFilterCategoryTypes() const
 	return mFilterOps.mFilterCategoryTypes;
 }
 
-BOOL LLInventoryFilter::hasFilterString() const
+U64 LLInventoryFilter::getFilterWearableTypes() const
+{
+	return mFilterOps.mFilterWearableTypes;
+}
+
+bool LLInventoryFilter::hasFilterString() const
 {
 	return mFilterSubString.size() > 0;
 }
@@ -1073,10 +1083,6 @@ U32 LLInventoryFilter::getSortOrder() const
 { 
 	return mOrder; 
 }
-const std::string& LLInventoryFilter::getName() const 
-{ 
-	return mName; 
-}
 
 void LLInventoryFilter::setFilterCount(S32 count) 
 { 
@@ -1110,8 +1116,8 @@ void LLInventoryFilter::setEmptyLookupMessage(const std::string& message)
 	mEmptyLookupMessage = message;
 }
 
-RN: turn this into a param
-const std::string& LLInventoryFilter::getEmptyLookupMessage() const
+// TODO RN: turn this into a param and move to llfolderviewmodelinterface
+std::string LLInventoryFilter::getEmptyLookupMessage() const
 {
 	LLStringUtil::format_map_t args;
 	args["[SEARCH_TERM]"] = LLURI::escape(getFilterSubStringOrig());
@@ -1127,11 +1133,6 @@ bool LLInventoryFilter::areDateLimitsSet()
 			|| mFilterOps.mHoursAgo != 0;
 }
 
-LLInventoryFilter& LLInventoryFilter::operator=( const  LLInventoryFilter&  other )
-{
-	fromParams(other.toParams());
-}
-
 bool LLInventoryFilter::showAllResults() const
 {
 	return hasFilterString();
@@ -1139,7 +1140,7 @@ bool LLInventoryFilter::showAllResults() const
 
 
 
-bool LLInventoryFilter::FilterOps::DateRange::validateBlock( bool   emit_errors /*= true*/ )
+bool LLInventoryFilter::FilterOps::DateRange::validateBlock( bool   emit_errors /*= true*/ ) const
 {
 	bool valid = LLInitParam::Block<DateRange>::validateBlock(emit_errors);
 	if (valid)
diff --git a/indra/newview/llinventoryfilter.h b/indra/newview/llinventoryfilter.h
index 746e9a2820..e0c3d7141b 100644
--- a/indra/newview/llinventoryfilter.h
+++ b/indra/newview/llinventoryfilter.h
@@ -144,16 +144,18 @@ public:
 		{}
 	};
 									
-	LLInventoryFilter(const std::string& name, const Params& p);
-	virtual ~LLInventoryFilter();
+	LLInventoryFilter(const Params& p = Params());
+	LLInventoryFilter(const LLInventoryFilter& other) { *this = other; }
+	virtual ~LLInventoryFilter() {}
 
 	// +-------------------------------------------------------------------+
 	// + Parameters
 	// +-------------------------------------------------------------------+
-	void 				setFilterObjectTypes(U64 types);
 	U64 				getFilterObjectTypes() const;
 	U64					getFilterCategoryTypes() const;
+	U64					getFilterWearableTypes() const;
 	bool 				isFilterObjectTypesWith(LLInventoryType::EType t) const;
+	void 				setFilterObjectTypes(U64 types);
 	void 				setFilterCategoryTypes(U64 types);
 	void 				setFilterUUID(const LLUUID &object_id);
 	void				setFilterWearableTypes(U64 types);
@@ -209,20 +211,19 @@ public:
 	U32 				getSortOrder() const;
 
 	void 				setEmptyLookupMessage(const std::string& message);
-	const std::string&	getEmptyLookupMessage() const;
+	std::string			getEmptyLookupMessage() const;
 
 	// +-------------------------------------------------------------------+
 	// + Status
 	// +-------------------------------------------------------------------+
 	bool 				isActive() const;
 	bool 				isModified() const;
-	bool 				isModifiedAndClear();
 	bool 				isSinceLogoff() const;
 	void 				clearModified();
 	const std::string& 	getName() const;
 	const std::string& 	getFilterText();
 	//RN: this is public to allow system to externally force a global refilter
-	void 				setModified(EFilterBehavior behavior = FILTER_RESTART);
+	void 				setModified(EFilterModified behavior = FILTER_RESTART);
 
 	// +-------------------------------------------------------------------+
 	// + Count
@@ -259,15 +260,12 @@ private:
 	bool				areDateLimitsSet();
 
 	U32						mOrder;
-	U32 					mLastLogoff;
 
-	std::string::size_type	mSubStringMatchOffset;
 	FilterOps				mFilterOps;
 	FilterOps				mDefaultFilterOps;
 
 	std::string				mFilterSubString;
 	std::string				mFilterSubStringOrig;
-	const std::string		mName;
 
 	S32						mLastSuccessGeneration;
 	S32						mLastFailGeneration;
@@ -275,10 +273,8 @@ private:
 	S32						mNextFilterGeneration;
 
 	S32						mFilterCount;
-	EFilterBehavior 		mFilterBehavior;
+	EFilterModified 		mFilterModified;
 
-	BOOL 					mModified;
-	BOOL 					mNeedTextRebuild;
 	std::string 			mFilterText;
 	std::string 			mEmptyLookupMessage;
 };
diff --git a/indra/newview/llinventoryfunctions.h b/indra/newview/llinventoryfunctions.h
index 5cf9c528b0..c6b1da0417 100644
--- a/indra/newview/llinventoryfunctions.h
+++ b/indra/newview/llinventoryfunctions.h
@@ -418,21 +418,6 @@ public:
 class LLFolderViewItem;
 class LLFolderViewFolder;
 
-//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-// Class LLFolderViewFunctor
-//
-// Simple abstract base class for applying a functor to folders and
-// items in a folder view hierarchy. This is suboptimal for algorithms
-// that only work folders or only work on items, but I'll worry about
-// that later when it's determined to be too slow.
-//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-class LLFolderViewFunctor
-{
-public:
-	virtual ~LLFolderViewFunctor() {}
-	virtual void doFolder(LLFolderViewFolder* folder) = 0;
-	virtual void doItem(LLFolderViewItem* item) = 0;
-};
 
 class LLInventoryState
 {
@@ -442,49 +427,6 @@ public:
 	static LLUUID sWearNewClothingTransactionID;	// wear all clothing in this transaction	
 };
 
-class LLSelectFirstFilteredItem : public LLFolderViewFunctor
-{
-public:
-	LLSelectFirstFilteredItem() : mItemSelected(FALSE) {}
-	virtual ~LLSelectFirstFilteredItem() {}
-	virtual void doFolder(LLFolderViewFolder* folder);
-	virtual void doItem(LLFolderViewItem* item);
-	BOOL wasItemSelected() { return mItemSelected; }
-protected:
-	BOOL mItemSelected;
-};
-
-class LLOpenFilteredFolders : public LLFolderViewFunctor
-{
-public:
-	LLOpenFilteredFolders()  {}
-	virtual ~LLOpenFilteredFolders() {}
-	virtual void doFolder(LLFolderViewFolder* folder);
-	virtual void doItem(LLFolderViewItem* item);
-};
-
-class LLSaveFolderState : public LLFolderViewFunctor
-{
-public:
-	LLSaveFolderState() : mApply(FALSE) {}
-	virtual ~LLSaveFolderState() {}
-	virtual void doFolder(LLFolderViewFolder* folder);
-	virtual void doItem(LLFolderViewItem* item) {}
-	void setApply(BOOL apply);
-	void clearOpenFolders() { mOpenFolders.clear(); }
-protected:
-	std::set<LLUUID> mOpenFolders;
-	BOOL mApply;
-};
-
-class LLOpenFoldersWithSelection : public LLFolderViewFunctor
-{
-public:
-	LLOpenFoldersWithSelection() {}
-	virtual ~LLOpenFoldersWithSelection() {}
-	virtual void doFolder(LLFolderViewFolder* folder);
-	virtual void doItem(LLFolderViewItem* item);
-};
 
 #endif // LL_LLINVENTORYFUNCTIONS_H
 
diff --git a/indra/newview/llinventorypanel.cpp b/indra/newview/llinventorypanel.cpp
index 401daf6353..e739694fe0 100644
--- a/indra/newview/llinventorypanel.cpp
+++ b/indra/newview/llinventorypanel.cpp
@@ -76,7 +76,7 @@ void LLFolderViewModelInventory::sort( LLFolderViewFolder* folder )
 {
 	LLFastTimer _(FTM_INVENTORY_SORT);
 
-	if (!needsSort(folder)) return;
+	if (!needsSort(folder->getViewModelItem())) return;
 
 	LLFolderViewModelItemInventory* modelp =   static_cast<LLFolderViewModelItemInventory*>(folder->getViewModelItem());
 	if (modelp->getUUID().isNull()) return;
@@ -91,7 +91,7 @@ void LLFolderViewModelInventory::sort( LLFolderViewFolder* folder )
 		if (child_folderp->getFoldersCount() > 0)
 		{
 			time_t most_recent_folder_time =
-				static_cast<LLFolderViewModelItemInventory*>(child_folderp->getFoldersBegin()->getViewModelItem())->getCreationDate();
+				static_cast<LLFolderViewModelItemInventory*>((*child_folderp->getFoldersBegin())->getViewModelItem())->getCreationDate();
 			LLFolderViewModelItemInventory* modelp =   static_cast<LLFolderViewModelItemInventory*>(child_folderp->getViewModelItem());
 			if (most_recent_folder_time > modelp->getCreationDate())
 			{
@@ -101,7 +101,7 @@ void LLFolderViewModelInventory::sort( LLFolderViewFolder* folder )
 		if (child_folderp->getItemsCount() > 0)			
 		{
 			time_t most_recent_item_time =
-				static_cast<LLFolderViewModelItemInventory*>(child_folderp->getItemsBegin()->getViewModelItem())->getCreationDate();
+				static_cast<LLFolderViewModelItemInventory*>((*child_folderp->getItemsBegin())->getViewModelItem())->getCreationDate();
 
 			LLFolderViewModelItemInventory* modelp =   static_cast<LLFolderViewModelItemInventory*>(child_folderp->getViewModelItem());
 			if (most_recent_item_time > modelp->getCreationDate())
@@ -113,6 +113,12 @@ void LLFolderViewModelInventory::sort( LLFolderViewFolder* folder )
 	base_t::sort(folder);
 }
 
+bool LLFolderViewModelInventory::contentsReady()
+{
+	return !LLInventoryModelBackgroundFetch::instance().folderFetchActive();
+}
+
+
 //~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 // Class LLInventoryPanelObserver
 //
@@ -243,6 +249,7 @@ void LLInventoryPanel::buildFolderView(const LLInventoryPanel::Params& params)
 																	root_id);
 	
 	mFolderRoot = createFolderView(new_listener, params.use_label_suffix());
+	addItemID(root_id, mFolderRoot);
 }
 
 void LLInventoryPanel::initFromParams(const LLInventoryPanel::Params& params)
@@ -314,11 +321,11 @@ void LLInventoryPanel::initFromParams(const LLInventoryPanel::Params& params)
 
 LLInventoryPanel::~LLInventoryPanel()
 {
-        U32 sort_order = getViewModel()->getSortOrder();
-		if (mSortOrderSetting != INHERIT_SORT_ORDER)
-		{
-			gSavedSettings.setU32(mSortOrderSetting, sort_order);
-		}
+	U32 sort_order = getFolderViewModel()->getSorter().getSortOrder();
+	if (mSortOrderSetting != INHERIT_SORT_ORDER)
+	{
+		gSavedSettings.setU32(mSortOrderSetting, sort_order);
+	}
 
 	gIdleCallbacks.deleteFunction(onIdle, this);
 
@@ -346,14 +353,9 @@ void LLInventoryPanel::draw()
 	LLPanel::draw();
 }
 
-LLInventoryFilter* LLInventoryPanel::getFilter()
-{
-	return getViewModel()->getFilter();
-}
-
 const LLInventoryFilter* LLInventoryPanel::getFilter() const
 {
-	return getViewModel()->getFilter();
+	return &getFolderViewModel()->getFilter();
 }
 
 void LLInventoryPanel::setFilterTypes(U64 types, LLInventoryFilter::EFilterType filter_type)
@@ -400,9 +402,9 @@ void LLInventoryPanel::setSortOrder(U32 order)
 {
         LLInventorySort sorter(order);
 	getFilter()->setSortOrder(order);
-	if (order != getViewModel()->getSortOrder())
+	if (order != getFolderViewModel()->getSorter().getSortOrder())
 	{
-		getViewModel()->setSorter(LLInventorySort(order));
+		getFolderViewModel()->setSorter(LLInventorySort(order));
 		// try to keep selection onscreen, even if it wasn't to start with
 		mFolderRoot->scrollToShowSelection();
 	}
@@ -410,7 +412,7 @@ void LLInventoryPanel::setSortOrder(U32 order)
 
 U32 LLInventoryPanel::getSortOrder() const 
 { 
-	return getViewModel()->getSortOrder();
+	return getFolderViewModel()->getSorter().getSortOrder();
 }
 
 void LLInventoryPanel::setSinceLogoff(BOOL sl)
@@ -460,6 +462,8 @@ void LLInventoryPanel::modelChanged(U32 mask)
 		const LLUUID& item_id = (*items_iter);
 		const LLInventoryObject* model_item = model->getObject(item_id);
 		LLFolderViewItem* view_item = getItemByID(item_id);
+		LLFolderViewModelItemInventory* viewmodel_item = 
+			static_cast<LLFolderViewModelItemInventory*>(view_item ? view_item->getViewModelItem() : NULL);
 
 		// LLFolderViewFolder is derived from LLFolderViewItem so dynamic_cast from item
 		// to folder is the fast way to get a folder without searching through folders tree.
@@ -493,9 +497,11 @@ void LLInventoryPanel::modelChanged(U32 mask)
 			if (model_item && view_item)
 			{
 				view_item->destroyView();
-                                removeItemID(view_item->getViewModelItem()->getUUID());
+				removeItemID(viewmodel_item->getUUID());
 			}
 			view_item = buildNewViews(item_id);
+			viewmodel_item = 
+				static_cast<LLFolderViewModelItemInventory*>(view_item ? view_item->getViewModelItem() : NULL);
 			view_folder = dynamic_cast<LLFolderViewFolder *>(view_item);
 		}
 
@@ -563,14 +569,14 @@ void LLInventoryPanel::modelChanged(U32 mask)
 							// Item is to be moved and we found its new parent in the panel's directory, so move the item's UI.
 							view_item->getParentFolder()->extractItem(view_item);
 							view_item->addToFolder(new_parent);
-							addItemID(view_item->getViewModelItem()->getUUID(), view_item);
+							addItemID(viewmodel_item->getUUID(), view_item);
 						}
 						else 
 						{
 							// Item is to be moved outside the panel's directory (e.g. moved to trash for a panel that 
 							// doesn't include trash).  Just remove the item's UI.
 							view_item->destroyView();
-                                                        removeItemID(view_item->getViewModelItem()->getUUID());
+                            removeItemID(viewmodel_item->getUUID());
 						}
 					}
 				}
@@ -583,7 +589,7 @@ void LLInventoryPanel::modelChanged(U32 mask)
 			{
 				// Remove the item's UI.
 				view_item->destroyView();
-                                removeItemID(view_item->getViewModelItem()->getUUID());
+                removeItemID(viewmodel_item->getUUID());
 			}
 		}
 	}
@@ -613,16 +619,11 @@ void LLInventoryPanel::onIdle(void *userdata)
 	}
 }
 
-const LLUUID& LLInventoryPanel::getRootFolderID() const
-{
-	return mFolderRoot->getViewModelItem()->getUUID();
-}
-
 void LLInventoryPanel::initializeViews()
 {
 	if (!gInventory.isInventoryUsable()) return;
 
-	rebuildViewsFor(getRootFolderID());
+	rebuildViewsFor(gInventory.getRootFolderID());
 
 	mViewsInitialized = true;
 	
@@ -654,7 +655,7 @@ LLFolderViewItem* LLInventoryPanel::rebuildViewsFor(const LLUUID& id)
 	if (old_view)
 	{
 		old_view->destroyView();
-                removeItemID(old_view->getViewModelItem()->getUUID());
+		removeItemID(static_cast<LLFolderViewModelItemInventory*>(old_view->getViewModelItem())->getUUID());
 	}
 
 	return buildNewViews(id);
@@ -727,75 +728,65 @@ LLFolderViewItem * LLInventoryPanel::createFolderViewItem(LLInvFVBridge * bridge
 LLFolderViewItem* LLInventoryPanel::buildNewViews(const LLUUID& id)
 {
  	LLInventoryObject const* objectp = gInventory.getObject(id);
- 	LLUUID root_id = mFolderRoot->getViewModelItem()->getUUID();
- 	LLFolderViewFolder* parent_folder = NULL;
-	LLFolderViewItem* itemp = NULL;
 	
- 	if (id == root_id)
- 	{
- 		parent_folder = mFolderRoot;
- 	}
- 	else if (objectp)
- 	{
- 		const LLUUID &parent_id = objectp->getParentUUID();
- 		parent_folder = (LLFolderViewFolder*)getItemByID(parent_id);
-  		
-  		if (parent_folder)
+	if (!objectp) return NULL;
+
+	LLFolderViewItem* folder_view_item = getItemByID(id);
+	LLFolderViewFolder* parent_folder = folder_view_item->getParentFolder();
+	 
+ 	if (!folder_view_item && parent_folder)
+  	{
+  		if (objectp->getType() <= LLAssetType::AT_NONE ||
+  			objectp->getType() >= LLAssetType::AT_COUNT)
   		{
-  			if (objectp->getType() <= LLAssetType::AT_NONE ||
-  				objectp->getType() >= LLAssetType::AT_COUNT)
-  			{
-  				llwarns << "LLInventoryPanel::buildNewViews called with invalid objectp->mType : "
-  						<< ((S32) objectp->getType()) << " name " << objectp->getName() << " UUID " << objectp->getUUID()
-  						<< llendl;
-  				return NULL;
-  			}
+  			llwarns << "LLInventoryPanel::buildNewViews called with invalid objectp->mType : "
+  					<< ((S32) objectp->getType()) << " name " << objectp->getName() << " UUID " << objectp->getUUID()
+  					<< llendl;
+  			return NULL;
+  		}
   		
-  			if ((objectp->getType() == LLAssetType::AT_CATEGORY) &&
-  				(objectp->getActualType() != LLAssetType::AT_LINK_FOLDER))
+  		if ((objectp->getType() == LLAssetType::AT_CATEGORY) &&
+  			(objectp->getActualType() != LLAssetType::AT_LINK_FOLDER))
+  		{
+  			LLInvFVBridge* new_listener = mInvFVBridgeBuilder->createBridge(objectp->getType(),
+  																			objectp->getType(),
+  																			LLInventoryType::IT_CATEGORY,
+  																			this,
+  																			mFolderRoot,
+  																			objectp->getUUID());
+  			if (new_listener)
   			{
-  				LLInvFVBridge* new_listener = mInvFVBridgeBuilder->createBridge(objectp->getType(),
-  																				objectp->getType(),
-  																				LLInventoryType::IT_CATEGORY,
-  																				this,
-  																				mFolderRoot,
-  																				objectp->getUUID());
-  				if (new_listener)
-  				{
-					itemp = createFolderViewFolder(new_listener);
-  				}
+				folder_view_item = createFolderViewFolder(new_listener);
   			}
-  			else
-  			{
-  				// Build new view for item.
-  				LLInventoryItem* item = (LLInventoryItem*)objectp;
-  				LLInvFVBridge* new_listener = mInvFVBridgeBuilder->createBridge(item->getType(),
-  																				item->getActualType(),
-  																				item->getInventoryType(),
-  																				this,
-  																				mFolderRoot,
-  																				item->getUUID(),
-  																				item->getFlags());
+  		}
+  		else
+  		{
+  			// Build new view for item.
+  			LLInventoryItem* item = (LLInventoryItem*)objectp;
+  			LLInvFVBridge* new_listener = mInvFVBridgeBuilder->createBridge(item->getType(),
+  																			item->getActualType(),
+  																			item->getInventoryType(),
+  																			this,
+  																			mFolderRoot,
+  																			item->getUUID(),
+  																			item->getFlags());
  
-  				if (new_listener)
-  				{
-					itemp = createFolderViewItem(new_listener);
-  				}
+  			if (new_listener)
+  			{
+				folder_view_item = createFolderViewItem(new_listener);
   			}
+  		}
  
-  			if (itemp)
-  			{
-  				itemp->addToFolder(parent_folder);
-				addItemID(itemp->getViewModelItem()->getUUID(), itemp);
-   			}
-		}
+  		if (folder_view_item)
+  		{
+  			folder_view_item->addToFolder(parent_folder);
+			addItemID(id, folder_view_item);
+   		}
 	}
 
 	// If this is a folder, add the children of the folder and recursively add any 
 	// child folders.
-	if (id.isNull()
-		||	(objectp
-			&& objectp->getType() == LLAssetType::AT_CATEGORY))
+	if (folder_view_item && objectp->getType() == LLAssetType::AT_CATEGORY)
 	{
 		LLViewerInventoryCategory::cat_array_t* categories;
 		LLViewerInventoryItem::item_array_t* items;
@@ -812,7 +803,7 @@ LLFolderViewItem* LLInventoryPanel::buildNewViews(const LLUUID& id)
 			}
 		}
 		
-		if(items && parent_folder)
+		if(items)
 		{
 			for (LLViewerInventoryItem::item_array_t::const_iterator item_iter = items->begin();
 				 item_iter != items->end();
@@ -825,7 +816,7 @@ LLFolderViewItem* LLInventoryPanel::buildNewViews(const LLUUID& id)
 		mInventory->unlockDirectDescendentArrays(id);
 	}
 	
-	return itemp;
+	return folder_view_item;
 }
 
 // bit of a hack to make sure the inventory is open.
@@ -837,7 +828,7 @@ void LLInventoryPanel::openStartFolderOrMyInventory()
 		LLFolderViewFolder *fchild = dynamic_cast<LLFolderViewFolder*>(child);
 		if (fchild
 			&& fchild->getViewModelItem()
-				&& fchild->getViewModelItem()->getUUID() == gInventory.getRootFolderID())
+			&& fchild->getViewModelItem()->getName() == "My Inventory")
 		{
 			fchild->setOpen(TRUE);
 			break;
@@ -980,7 +971,7 @@ void LLInventoryPanel::onSelectionChange(const std::deque<LLFolderViewItem*>& it
 	mCompletionObserver->reset();
 	for (std::deque<LLFolderViewItem*>::const_iterator it = items.begin(); it != items.end(); ++it)
 	{
-		LLUUID id = (*it)->getViewModelItem()->getUUID();
+		LLUUID id = static_cast<LLFolderViewModelItemInventory*>((*it)->getViewModelItem())->getUUID();
 		LLViewerInventoryItem* inv_item = mInventory->getItem(id);
 
 		if (inv_item && !inv_item->isFinished())
@@ -1028,7 +1019,7 @@ bool LLInventoryPanel::beginIMSession()
 			
 		if(folder_item) 
 		{
-			LLFolderViewEventListener* fve_listener = folder_item->getViewModelItem();
+			LLFolderViewModelItemInventory* fve_listener = static_cast<LLFolderViewModelItemInventory*>(folder_item->getViewModelItem());
 			if (fve_listener && (fve_listener->getInventoryType() == LLInventoryType::IT_CATEGORY))
 			{
 
@@ -1107,13 +1098,13 @@ bool LLInventoryPanel::beginIMSession()
 bool LLInventoryPanel::attachObject(const LLSD& userdata)
 {
 	// Copy selected item UUIDs to a vector.
-	std::set<LLFolderViewItem*> selected_items =   mFolderRoot->getSelectionList();
+	std::set<LLFolderViewItem*> selected_items = mFolderRoot->getSelectionList();
 	uuid_vec_t items;
-	for (std::set<LLFolderViewItem*>::const_iterator set_iter =   selected_items.begin();
+	for (std::set<LLFolderViewItem*>::const_iterator set_iter = selected_items.begin();
 		 set_iter != selected_items.end(); 
 		 ++set_iter)
 	{
-		items.push_back((*set_iter)->getItemViewModel()->getUUID());
+		items.push_back(static_cast<LLFolderViewModelItemInventory*>((*set_iter)->getViewModelItem())->getUUID());
 	}
 
 	// Attach selected items.
@@ -1292,10 +1283,6 @@ LLFastTimer::DeclareTimer FTM_GET_ITEM_BY_ID("Get FolderViewItem by ID");
 LLFolderViewItem* LLInventoryPanel::getItemByID(const LLUUID& id)
 {
 	LLFastTimer _(FTM_GET_ITEM_BY_ID);
-	if (id == mFolderRoot->getViewModelItem()->getUUID())
-	{
-		return mFolderRoot;
-	}
 
 	std::map<LLUUID, LLFolderViewItem*>::iterator map_it;
 	map_it = mItemMap.find(id);
diff --git a/indra/newview/llinventorypanel.h b/indra/newview/llinventorypanel.h
index 467c508aa0..cd32b18779 100644
--- a/indra/newview/llinventorypanel.h
+++ b/indra/newview/llinventorypanel.h
@@ -66,22 +66,21 @@ public:
 class LLInventorySort
 {
 public:
-	LLInventorySort(U32 order)
-		:	mSortOrder(0),
+	LLInventorySort(U32 order = 0)
+	:	mSortOrder(order),
 		mByDate(false),
 		mSystemToTop(false),
 		mFoldersByName(false)
 	{
-		mSortOrder = order;
 		mByDate = (order & LLInventoryFilter::SO_DATE);
 		mSystemToTop = (order & LLInventoryFilter::SO_SYSTEM_FOLDERS_TO_TOP);
 		mFoldersByName = (order & LLInventoryFilter::SO_FOLDERS_BY_NAME);
 	}
 
-	bool isByDate() { return mByDate; }
-	U32 getSortOrder() { return mSortOrder; }
+	bool isByDate() const { return mByDate; }
+	U32 getSortOrder() const { return mSortOrder; }
 
-	bool operator()(const LLFolderViewModelItemInventory* const& a, const LLFolderViewModelItemInventory* const& b);
+	bool operator()(const LLFolderViewModelItemInventory* const& a, const LLFolderViewModelItemInventory* const& b) const;
 private:
 	U32  mSortOrder;
 	bool mByDate;
@@ -92,12 +91,16 @@ private:
 class LLFolderViewModelInventory
 	:	public LLFolderViewModel<LLInventorySort,   LLFolderViewModelItemInventory, LLFolderViewModelItemInventory,   LLInventoryFilter>
 {
+public:
 	typedef LLFolderViewModel<LLInventorySort,   LLFolderViewModelItemInventory, LLFolderViewModelItemInventory,   LLInventoryFilter> base_t;
 
 	virtual ~LLFolderViewModelInventory() {}
 
 	void sort(LLFolderViewFolder* folder);
 	void requestSort(LLFolderViewFolder* folder);
+
+	bool contentsReady();
+
 };
 
 
@@ -234,7 +237,7 @@ public:
 	void updateSelection();
 	 	
 	LLFolderViewModelInventory* getFolderViewModel() { return &mViewModel; }
-	const LLFolderViewModelInventory* getFolderViewModel() const { return   &mViewModel; }
+	const LLFolderViewModelInventory* getFolderViewModel() const { return &mViewModel; }
 
 protected:
 	void openStartFolderOrMyInventory(); // open the first level of inventory
@@ -287,8 +290,7 @@ public:
 	void addHideFolderType(LLFolderType::EType folder_type);
 
 public:
-	BOOL 				getIsViewsInitialized() const { return mViewsInitialized; }
-	const LLUUID&		getRootFolderID() const;
+	BOOL getIsViewsInitialized() const { return mViewsInitialized; }
 protected:
 	// Builds the UI.  Call this once the inventory is usable.
 	void 				initializeViews();
diff --git a/indra/newview/llpanelobjectinventory.cpp b/indra/newview/llpanelobjectinventory.cpp
index 240c5b2da4..ae68b5ce95 100644
--- a/indra/newview/llpanelobjectinventory.cpp
+++ b/indra/newview/llpanelobjectinventory.cpp
@@ -1542,7 +1542,7 @@ void LLPanelObjectInventory::reset()
 	p.folder_indentation = -14; // subtract space normally reserved for folder expanders
 	mFolders = LLUICtrlFactory::create<LLFolderView>(p);
 	// this ensures that we never say "searching..." or "no items found"
-	RN: make this happen by manipulating filter object directly
+	//TODO RN: make this happen by manipulating filter object directly
 	//mFolders->getFilter()->setShowFolderState(LLInventoryFilter::SHOW_ALL_FOLDERS);
 	mFolders->setCallbackRegistrar(&mCommitCallbackRegistrar);
 
diff --git a/indra/newview/llsidepanelinventory.h b/indra/newview/llsidepanelinventory.h
index 6aa349f0f3..e8b2808d4f 100644
--- a/indra/newview/llsidepanelinventory.h
+++ b/indra/newview/llsidepanelinventory.h
@@ -63,8 +63,7 @@ public:
 	BOOL isMainInventoryPanelActive() const;
 
 	void clearSelections(bool clearMain, bool clearInbox);
-        std::set<LLFolderViewItem*> getInboxSelectionList();
-	std::set<LLUUID> getInboxSelectionList();
+    std::set<LLFolderViewItem*> getInboxSelectionList();
 
 	void showItemInfoPanel();
 	void showTaskInfoPanel();