Merge remote-tracking branch 'origin/DRTVWR-600-maint-A' into brad/merge-maint-a-to-dev

1 files changed, 1097 insertions, 1097 deletions

diff --git a/indra/newview/llpanelmaininventory.cpp b/indra/newview/llpanelmaininventory.cpp
index f20b135faf..ba52da0760 100644
--- a/indra/newview/llpanelmaininventory.cpp
+++ b/indra/newview/llpanelmaininventory.cpp
@@ -1,25 +1,25 @@
-/** 
+/**
  * @file llpanelmaininventory.cpp
  * @brief Implementation of llpanelmaininventory.
  *
  * $LicenseInfo:firstyear=2001&license=viewerlgpl$
  * Second Life Viewer Source Code
  * Copyright (C) 2010, Linden Research, Inc.
- * 
+ *
  * This library is free software; you can redistribute it and/or
  * modify it under the terms of the GNU Lesser General Public
  * License as published by the Free Software Foundation;
  * version 2.1 of the License only.
- * 
+ *
  * This library is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  * Lesser General Public License for more details.
- * 
+ *
  * You should have received a copy of the GNU Lesser General Public
  * License along with this library; if not, write to the Free Software
  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
- * 
+ *
  * Linden Research, Inc., 945 Battery Street, San Francisco, CA  94111  USA
  * $/LicenseInfo$
  */
@@ -78,29 +78,29 @@ static LLPanelInjector<LLPanelMainInventory> t_inventory("panel_main_inventory")
 class LLFloaterInventoryFinder : public LLFloater
 {
 public:
-	LLFloaterInventoryFinder( LLPanelMainInventory* inventory_view);
-	virtual void draw();
-	/*virtual*/	bool	postBuild();
-	void changeFilter(LLInventoryFilter* filter);
-	void updateElementsFromFilter();
-	bool getCheckShowEmpty();
-	bool getCheckSinceLogoff();
-	U32 getDateSearchDirection();
-
-	void onCreatorSelfFilterCommit();
-	void onCreatorOtherFilterCommit();
-
-	static void onTimeAgo(LLUICtrl*, void *);
-	static void onCloseBtn(void* user_data);
-	static void selectAllTypes(void* user_data);
-	static void selectNoTypes(void* user_data);
+    LLFloaterInventoryFinder( LLPanelMainInventory* inventory_view);
+    virtual void draw();
+    /*virtual*/ bool    postBuild();
+    void changeFilter(LLInventoryFilter* filter);
+    void updateElementsFromFilter();
+    bool getCheckShowEmpty();
+    bool getCheckSinceLogoff();
+    U32 getDateSearchDirection();
+
+    void onCreatorSelfFilterCommit();
+    void onCreatorOtherFilterCommit();
+
+    static void onTimeAgo(LLUICtrl*, void *);
+    static void onCloseBtn(void* user_data);
+    static void selectAllTypes(void* user_data);
+    static void selectNoTypes(void* user_data);
 private:
-	LLPanelMainInventory*	mPanelMainInventory;
-	LLSpinCtrl*			mSpinSinceDays;
-	LLSpinCtrl*			mSpinSinceHours;
-	LLCheckBoxCtrl*		mCreatorSelf;
-	LLCheckBoxCtrl*		mCreatorOthers;
-	LLInventoryFilter*	mFilter;
+    LLPanelMainInventory*   mPanelMainInventory;
+    LLSpinCtrl*         mSpinSinceDays;
+    LLSpinCtrl*         mSpinSinceHours;
+    LLCheckBoxCtrl*     mCreatorSelf;
+    LLCheckBoxCtrl*     mCreatorOthers;
+    LLInventoryFilter*  mFilter;
 };
 
 ///----------------------------------------------------------------------------
@@ -108,15 +108,15 @@ private:
 ///----------------------------------------------------------------------------
 
 LLPanelMainInventory::LLPanelMainInventory(const LLPanel::Params& p)
-	: LLPanel(p),
-	  mActivePanel(NULL),
-	  mWornItemsPanel(NULL),
-	  mSavedFolderState(NULL),
-	  mFilterText(""),
-	  mMenuGearDefault(NULL),
-	  mMenuVisibility(NULL),
-	  mMenuAddHandle(),
-	  mNeedUploadCost(true),
+    : LLPanel(p),
+      mActivePanel(NULL),
+      mWornItemsPanel(NULL),
+      mSavedFolderState(NULL),
+      mFilterText(""),
+      mMenuGearDefault(NULL),
+      mMenuVisibility(NULL),
+      mMenuAddHandle(),
+      mNeedUploadCost(true),
       mMenuViewDefault(NULL),
       mSingleFolderMode(false),
       mForceShowInvLayout(false),
@@ -124,128 +124,128 @@ LLPanelMainInventory::LLPanelMainInventory(const LLPanel::Params& p)
       mListViewRootUpdatedConnection(),
       mGalleryRootUpdatedConnection()
 {
-	// Menu Callbacks (non contex menus)
-	mCommitCallbackRegistrar.add("Inventory.DoToSelected", boost::bind(&LLPanelMainInventory::doToSelected, this, _2));
-	mCommitCallbackRegistrar.add("Inventory.CloseAllFolders", boost::bind(&LLPanelMainInventory::closeAllFolders, this));
-	mCommitCallbackRegistrar.add("Inventory.EmptyTrash", boost::bind(&LLInventoryModel::emptyFolderType, &gInventory, "ConfirmEmptyTrash", LLFolderType::FT_TRASH));
-	mCommitCallbackRegistrar.add("Inventory.EmptyLostAndFound", boost::bind(&LLInventoryModel::emptyFolderType, &gInventory, "ConfirmEmptyLostAndFound", LLFolderType::FT_LOST_AND_FOUND));
-	mCommitCallbackRegistrar.add("Inventory.DoCreate", boost::bind(&LLPanelMainInventory::doCreate, this, _2));
-	mCommitCallbackRegistrar.add("Inventory.ShowFilters", boost::bind(&LLPanelMainInventory::toggleFindOptions, this));
-	mCommitCallbackRegistrar.add("Inventory.ResetFilters", boost::bind(&LLPanelMainInventory::resetFilters, this));
-	mCommitCallbackRegistrar.add("Inventory.SetSortBy", boost::bind(&LLPanelMainInventory::setSortBy, this, _2));
+    // Menu Callbacks (non contex menus)
+    mCommitCallbackRegistrar.add("Inventory.DoToSelected", boost::bind(&LLPanelMainInventory::doToSelected, this, _2));
+    mCommitCallbackRegistrar.add("Inventory.CloseAllFolders", boost::bind(&LLPanelMainInventory::closeAllFolders, this));
+    mCommitCallbackRegistrar.add("Inventory.EmptyTrash", boost::bind(&LLInventoryModel::emptyFolderType, &gInventory, "ConfirmEmptyTrash", LLFolderType::FT_TRASH));
+    mCommitCallbackRegistrar.add("Inventory.EmptyLostAndFound", boost::bind(&LLInventoryModel::emptyFolderType, &gInventory, "ConfirmEmptyLostAndFound", LLFolderType::FT_LOST_AND_FOUND));
+    mCommitCallbackRegistrar.add("Inventory.DoCreate", boost::bind(&LLPanelMainInventory::doCreate, this, _2));
+    mCommitCallbackRegistrar.add("Inventory.ShowFilters", boost::bind(&LLPanelMainInventory::toggleFindOptions, this));
+    mCommitCallbackRegistrar.add("Inventory.ResetFilters", boost::bind(&LLPanelMainInventory::resetFilters, this));
+    mCommitCallbackRegistrar.add("Inventory.SetSortBy", boost::bind(&LLPanelMainInventory::setSortBy, this, _2));
 
     mEnableCallbackRegistrar.add("Inventory.EnvironmentEnabled", [](LLUICtrl *, const LLSD &) { return LLPanelMainInventory::hasSettingsInventory(); });
     mEnableCallbackRegistrar.add("Inventory.MaterialsEnabled", [](LLUICtrl *, const LLSD &) { return LLPanelMainInventory::hasMaterialsInventory(); });
 
 
-	mSavedFolderState = new LLSaveFolderState();
-	mSavedFolderState->setApply(false);
+    mSavedFolderState = new LLSaveFolderState();
+    mSavedFolderState->setApply(false);
 }
 
 bool LLPanelMainInventory::postBuild()
 {
-	gInventory.addObserver(this);
-	
-	mFilterTabs = getChild<LLTabContainer>("inventory filter tabs");
-	mFilterTabs->setCommitCallback(boost::bind(&LLPanelMainInventory::onFilterSelected, this));
-	
+    gInventory.addObserver(this);
+
+    mFilterTabs = getChild<LLTabContainer>("inventory filter tabs");
+    mFilterTabs->setCommitCallback(boost::bind(&LLPanelMainInventory::onFilterSelected, this));
+
     mCounterCtrl = getChild<LLUICtrl>("ItemcountText");
-    
-	//panel->getFilter().markDefault();
-
-	// Set up the default inv. panel/filter settings.
-	mActivePanel = getChild<LLInventoryPanel>(ALL_ITEMS);
-	if (mActivePanel)
-	{
-		// "All Items" is the previous only view, so it gets the InventorySortOrder
-		mActivePanel->setSortOrder(gSavedSettings.getU32(LLInventoryPanel::DEFAULT_SORT_ORDER));
-		mActivePanel->getFilter().markDefault();
-		mActivePanel->getRootFolder()->applyFunctorRecursively(*mSavedFolderState);
-		mActivePanel->setSelectCallback(boost::bind(&LLPanelMainInventory::onSelectionChange, this, mActivePanel, _1, _2));
-		mResortActivePanel = true;
-	}
-	LLInventoryPanel* recent_items_panel = getChild<LLInventoryPanel>(RECENT_ITEMS);
-	if (recent_items_panel)
-	{
-		// assign default values until we will be sure that we have setting to restore
-		recent_items_panel->setSinceLogoff(true);
-		recent_items_panel->setSortOrder(LLInventoryFilter::SO_DATE);
-		recent_items_panel->setShowFolderState(LLInventoryFilter::SHOW_NON_EMPTY_FOLDERS);
-		LLInventoryFilter& recent_filter = recent_items_panel->getFilter();
-		recent_filter.setFilterObjectTypes(recent_filter.getFilterObjectTypes() & ~(0x1 << LLInventoryType::IT_CATEGORY));
-		recent_filter.setEmptyLookupMessage("InventoryNoMatchingRecentItems");
-		recent_filter.markDefault();
-		recent_items_panel->setSelectCallback(boost::bind(&LLPanelMainInventory::onSelectionChange, this, recent_items_panel, _1, _2));
-	}
-
-	mWornItemsPanel = getChild<LLInventoryPanel>(WORN_ITEMS);
-	if (mWornItemsPanel)
-	{
-		U32 filter_types = 0x0;
-		filter_types |= 0x1 << LLInventoryType::IT_WEARABLE;
-		filter_types |= 0x1 << LLInventoryType::IT_ATTACHMENT;
-		filter_types |= 0x1 << LLInventoryType::IT_OBJECT;
-		mWornItemsPanel->setFilterTypes(filter_types);
-		mWornItemsPanel->setFilterWorn();
-		mWornItemsPanel->setShowFolderState(LLInventoryFilter::SHOW_NON_EMPTY_FOLDERS);
-		mWornItemsPanel->setFilterLinks(LLInventoryFilter::FILTERLINK_EXCLUDE_LINKS);
-		LLInventoryFilter& worn_filter = mWornItemsPanel->getFilter();
-		worn_filter.setFilterCategoryTypes(worn_filter.getFilterCategoryTypes() | (1ULL << LLFolderType::FT_INBOX));
-		worn_filter.markDefault();
-		mWornItemsPanel->setSelectCallback(boost::bind(&LLPanelMainInventory::onSelectionChange, this, mWornItemsPanel, _1, _2));
-	}
-	mSearchTypeCombo  = getChild<LLComboBox>("search_type");
-	if(mSearchTypeCombo)
-	{
-		mSearchTypeCombo->setCommitCallback(boost::bind(&LLPanelMainInventory::onSelectSearchType, this));
-	}
-	// Now load the stored settings from disk, if available.
-	std::string filterSaveName(gDirUtilp->getExpandedFilename(LL_PATH_PER_SL_ACCOUNT, FILTERS_FILENAME));
-	LL_INFOS("Inventory") << "LLPanelMainInventory::init: reading from " << filterSaveName << LL_ENDL;
-	llifstream file(filterSaveName.c_str());
-	LLSD savedFilterState;
-	if (file.is_open())
-	{
-		LLSDSerialize::fromXML(savedFilterState, file);
-		file.close();
-
-		// Load the persistent "Recent Items" settings.
-		// Note that the "All Items" settings do not persist.
-		if(recent_items_panel)
-		{
-			if(savedFilterState.has(recent_items_panel->getFilter().getName()))
-			{
-				LLSD recent_items = savedFilterState.get(
-					recent_items_panel->getFilter().getName());
-				LLInventoryFilter::Params p;
-				LLParamSDParser parser;
-				parser.readSD(recent_items, p);
-				recent_items_panel->getFilter().fromParams(p);
-				recent_items_panel->setSortOrder(gSavedSettings.getU32(LLInventoryPanel::RECENTITEMS_SORT_ORDER));
-			}
-		}
-		if(mActivePanel)
-		{
-			if(savedFilterState.has(mActivePanel->getFilter().getName()))
-			{
-				LLSD items = savedFilterState.get(mActivePanel->getFilter().getName());
-				LLInventoryFilter::Params p;
-				LLParamSDParser parser;
-				parser.readSD(items, p);
-				mActivePanel->getFilter().setSearchVisibilityTypes(p);
-			}
-		}
-
-	}
-
-	mFilterEditor = getChild<LLFilterEditor>("inventory search editor");
-	if (mFilterEditor)
-	{
-		mFilterEditor->setCommitCallback(boost::bind(&LLPanelMainInventory::onFilterEdit, this, _2));
-	}
-
-	mGearMenuButton = getChild<LLMenuButton>("options_gear_btn");
-	mVisibilityMenuButton = getChild<LLMenuButton>("options_visibility_btn");
+
+    //panel->getFilter().markDefault();
+
+    // Set up the default inv. panel/filter settings.
+    mActivePanel = getChild<LLInventoryPanel>(ALL_ITEMS);
+    if (mActivePanel)
+    {
+        // "All Items" is the previous only view, so it gets the InventorySortOrder
+        mActivePanel->setSortOrder(gSavedSettings.getU32(LLInventoryPanel::DEFAULT_SORT_ORDER));
+        mActivePanel->getFilter().markDefault();
+        mActivePanel->getRootFolder()->applyFunctorRecursively(*mSavedFolderState);
+        mActivePanel->setSelectCallback(boost::bind(&LLPanelMainInventory::onSelectionChange, this, mActivePanel, _1, _2));
+        mResortActivePanel = true;
+    }
+    LLInventoryPanel* recent_items_panel = getChild<LLInventoryPanel>(RECENT_ITEMS);
+    if (recent_items_panel)
+    {
+        // assign default values until we will be sure that we have setting to restore
+        recent_items_panel->setSinceLogoff(true);
+        recent_items_panel->setSortOrder(LLInventoryFilter::SO_DATE);
+        recent_items_panel->setShowFolderState(LLInventoryFilter::SHOW_NON_EMPTY_FOLDERS);
+        LLInventoryFilter& recent_filter = recent_items_panel->getFilter();
+        recent_filter.setFilterObjectTypes(recent_filter.getFilterObjectTypes() & ~(0x1 << LLInventoryType::IT_CATEGORY));
+        recent_filter.setEmptyLookupMessage("InventoryNoMatchingRecentItems");
+        recent_filter.markDefault();
+        recent_items_panel->setSelectCallback(boost::bind(&LLPanelMainInventory::onSelectionChange, this, recent_items_panel, _1, _2));
+    }
+
+    mWornItemsPanel = getChild<LLInventoryPanel>(WORN_ITEMS);
+    if (mWornItemsPanel)
+    {
+        U32 filter_types = 0x0;
+        filter_types |= 0x1 << LLInventoryType::IT_WEARABLE;
+        filter_types |= 0x1 << LLInventoryType::IT_ATTACHMENT;
+        filter_types |= 0x1 << LLInventoryType::IT_OBJECT;
+        mWornItemsPanel->setFilterTypes(filter_types);
+        mWornItemsPanel->setFilterWorn();
+        mWornItemsPanel->setShowFolderState(LLInventoryFilter::SHOW_NON_EMPTY_FOLDERS);
+        mWornItemsPanel->setFilterLinks(LLInventoryFilter::FILTERLINK_EXCLUDE_LINKS);
+        LLInventoryFilter& worn_filter = mWornItemsPanel->getFilter();
+        worn_filter.setFilterCategoryTypes(worn_filter.getFilterCategoryTypes() | (1ULL << LLFolderType::FT_INBOX));
+        worn_filter.markDefault();
+        mWornItemsPanel->setSelectCallback(boost::bind(&LLPanelMainInventory::onSelectionChange, this, mWornItemsPanel, _1, _2));
+    }
+    mSearchTypeCombo  = getChild<LLComboBox>("search_type");
+    if(mSearchTypeCombo)
+    {
+        mSearchTypeCombo->setCommitCallback(boost::bind(&LLPanelMainInventory::onSelectSearchType, this));
+    }
+    // Now load the stored settings from disk, if available.
+    std::string filterSaveName(gDirUtilp->getExpandedFilename(LL_PATH_PER_SL_ACCOUNT, FILTERS_FILENAME));
+    LL_INFOS("Inventory") << "LLPanelMainInventory::init: reading from " << filterSaveName << LL_ENDL;
+    llifstream file(filterSaveName.c_str());
+    LLSD savedFilterState;
+    if (file.is_open())
+    {
+        LLSDSerialize::fromXML(savedFilterState, file);
+        file.close();
+
+        // Load the persistent "Recent Items" settings.
+        // Note that the "All Items" settings do not persist.
+        if(recent_items_panel)
+        {
+            if(savedFilterState.has(recent_items_panel->getFilter().getName()))
+            {
+                LLSD recent_items = savedFilterState.get(
+                    recent_items_panel->getFilter().getName());
+                LLInventoryFilter::Params p;
+                LLParamSDParser parser;
+                parser.readSD(recent_items, p);
+                recent_items_panel->getFilter().fromParams(p);
+                recent_items_panel->setSortOrder(gSavedSettings.getU32(LLInventoryPanel::RECENTITEMS_SORT_ORDER));
+            }
+        }
+        if(mActivePanel)
+        {
+            if(savedFilterState.has(mActivePanel->getFilter().getName()))
+            {
+                LLSD items = savedFilterState.get(mActivePanel->getFilter().getName());
+                LLInventoryFilter::Params p;
+                LLParamSDParser parser;
+                parser.readSD(items, p);
+                mActivePanel->getFilter().setSearchVisibilityTypes(p);
+            }
+        }
+
+    }
+
+    mFilterEditor = getChild<LLFilterEditor>("inventory search editor");
+    if (mFilterEditor)
+    {
+        mFilterEditor->setCommitCallback(boost::bind(&LLPanelMainInventory::onFilterEdit, this, _2));
+    }
+
+    mGearMenuButton = getChild<LLMenuButton>("options_gear_btn");
+    mVisibilityMenuButton = getChild<LLMenuButton>("options_visibility_btn");
     mViewMenuButton = getChild<LLMenuButton>("view_btn");
 
     mBackBtn = getChild<LLButton>("back_btn");
@@ -275,73 +275,73 @@ bool LLPanelMainInventory::postBuild()
     mGalleryRootUpdatedConnection = mCombinationGalleryPanel->setRootChangedCallback(boost::bind(&LLPanelMainInventory::onCombinationRootChanged, this, true));
     mCombinationGalleryPanel->setSelectionChangeCallback(boost::bind(&LLPanelMainInventory::onCombinationGallerySelectionChanged, this, _1));
 
-	initListCommandsHandlers();
+    initListCommandsHandlers();
 
-	const std::string sound_upload_cost_str = std::to_string(LLAgentBenefitsMgr::current().getSoundUploadCost());
-	const std::string animation_upload_cost_str = std::to_string(LLAgentBenefitsMgr::current().getAnimationUploadCost());
+    const std::string sound_upload_cost_str = std::to_string(LLAgentBenefitsMgr::current().getSoundUploadCost());
+    const std::string animation_upload_cost_str = std::to_string(LLAgentBenefitsMgr::current().getAnimationUploadCost());
 
-	LLMenuGL* menu = (LLMenuGL*)mMenuAddHandle.get();
-	if (menu)
-	{
-		menu->getChild<LLMenuItemGL>("Upload Sound")->setLabelArg("[COST]", sound_upload_cost_str);
-		menu->getChild<LLMenuItemGL>("Upload Animation")->setLabelArg("[COST]", animation_upload_cost_str);
-	}
+    LLMenuGL* menu = (LLMenuGL*)mMenuAddHandle.get();
+    if (menu)
+    {
+        menu->getChild<LLMenuItemGL>("Upload Sound")->setLabelArg("[COST]", sound_upload_cost_str);
+        menu->getChild<LLMenuItemGL>("Upload Animation")->setLabelArg("[COST]", animation_upload_cost_str);
+    }
 
-	// Trigger callback for focus received so we can deselect items in inbox/outbox
-	LLFocusableElement::setFocusReceivedCallback(boost::bind(&LLPanelMainInventory::onFocusReceived, this));
+    // Trigger callback for focus received so we can deselect items in inbox/outbox
+    LLFocusableElement::setFocusReceivedCallback(boost::bind(&LLPanelMainInventory::onFocusReceived, this));
 
-	return true;
+    return true;
 }
 
 // Destroys the object
 LLPanelMainInventory::~LLPanelMainInventory( void )
 {
-	// Save the filters state.
-	// Some params types cannot be saved this way
-	// for example, LLParamSDParser doesn't know about U64,
-	// so some FilterOps params should be revised.
-	LLSD filterRoot;
-	LLInventoryPanel* all_items_panel = getChild<LLInventoryPanel>(ALL_ITEMS);
-	if (all_items_panel)
-	{
-		LLSD filterState;
-		LLInventoryPanel::InventoryState p;
-		all_items_panel->getFilter().toParams(p.filter);
-		all_items_panel->getRootViewModel().getSorter().toParams(p.sort);
-		if (p.validateBlock(false))
-		{
-			LLParamSDParser().writeSD(filterState, p);
-			filterRoot[all_items_panel->getName()] = filterState;
-		}
-	}
-
-	LLInventoryPanel* panel = findChild<LLInventoryPanel>(RECENT_ITEMS);
-	if (panel)
-	{
-		LLSD filterState;
-		LLInventoryPanel::InventoryState p;
-		panel->getFilter().toParams(p.filter);
-		panel->getRootViewModel().getSorter().toParams(p.sort);
-		if (p.validateBlock(false))
-		{
-			LLParamSDParser().writeSD(filterState, p);
-			filterRoot[panel->getName()] = filterState;
-		}
-	}
-
-	std::string filterSaveName(gDirUtilp->getExpandedFilename(LL_PATH_PER_SL_ACCOUNT, FILTERS_FILENAME));
-	llofstream filtersFile(filterSaveName.c_str());
-	if(!LLSDSerialize::toPrettyXML(filterRoot, filtersFile))
-	{
-		LL_WARNS() << "Could not write to filters save file " << filterSaveName << LL_ENDL;
-	}
-	else
-    {
-		filtersFile.close();
-    }
-    
-	gInventory.removeObserver(this);
-	delete mSavedFolderState;
+    // Save the filters state.
+    // Some params types cannot be saved this way
+    // for example, LLParamSDParser doesn't know about U64,
+    // so some FilterOps params should be revised.
+    LLSD filterRoot;
+    LLInventoryPanel* all_items_panel = getChild<LLInventoryPanel>(ALL_ITEMS);
+    if (all_items_panel)
+    {
+        LLSD filterState;
+        LLInventoryPanel::InventoryState p;
+        all_items_panel->getFilter().toParams(p.filter);
+        all_items_panel->getRootViewModel().getSorter().toParams(p.sort);
+        if (p.validateBlock(false))
+        {
+            LLParamSDParser().writeSD(filterState, p);
+            filterRoot[all_items_panel->getName()] = filterState;
+        }
+    }
+
+    LLInventoryPanel* panel = findChild<LLInventoryPanel>(RECENT_ITEMS);
+    if (panel)
+    {
+        LLSD filterState;
+        LLInventoryPanel::InventoryState p;
+        panel->getFilter().toParams(p.filter);
+        panel->getRootViewModel().getSorter().toParams(p.sort);
+        if (p.validateBlock(false))
+        {
+            LLParamSDParser().writeSD(filterState, p);
+            filterRoot[panel->getName()] = filterState;
+        }
+    }
+
+    std::string filterSaveName(gDirUtilp->getExpandedFilename(LL_PATH_PER_SL_ACCOUNT, FILTERS_FILENAME));
+    llofstream filtersFile(filterSaveName.c_str());
+    if(!LLSDSerialize::toPrettyXML(filterRoot, filtersFile))
+    {
+        LL_WARNS() << "Could not write to filters save file " << filterSaveName << LL_ENDL;
+    }
+    else
+    {
+        filtersFile.close();
+    }
+
+    gInventory.removeObserver(this);
+    delete mSavedFolderState;
 
     auto menu = mMenuAddHandle.get();
     if(menu)
@@ -362,57 +362,57 @@ LLPanelMainInventory::~LLPanelMainInventory( void )
 
 LLInventoryPanel* LLPanelMainInventory::getAllItemsPanel()
 {
-	return  getChild<LLInventoryPanel>(ALL_ITEMS);
+    return  getChild<LLInventoryPanel>(ALL_ITEMS);
 }
 
 void LLPanelMainInventory::selectAllItemsPanel()
 {
-	mFilterTabs->selectFirstTab();
+    mFilterTabs->selectFirstTab();
 }
 
 bool LLPanelMainInventory::isRecentItemsPanelSelected()
 {
-	return (RECENT_ITEMS == getActivePanel()->getName());
+    return (RECENT_ITEMS == getActivePanel()->getName());
 }
 
 void LLPanelMainInventory::startSearch()
 {
-	// this forces focus to line editor portion of search editor
-	if (mFilterEditor)
-	{
-		mFilterEditor->focusFirstItem(true);
-	}
+    // this forces focus to line editor portion of search editor
+    if (mFilterEditor)
+    {
+        mFilterEditor->focusFirstItem(true);
+    }
 }
 
 bool LLPanelMainInventory::handleKeyHere(KEY key, MASK mask)
 {
-	LLFolderView* root_folder = mActivePanel ? mActivePanel->getRootFolder() : NULL;
-	if (root_folder)
-	{
-		// first check for user accepting current search results
-		if (mFilterEditor 
-			&& mFilterEditor->hasFocus()
-		    && (key == KEY_RETURN 
-		    	|| key == KEY_DOWN)
-		    && mask == MASK_NONE)
-		{
-			// move focus to inventory proper
-			mActivePanel->setFocus(true);
-			root_folder->scrollToShowSelection();
-			return true;
-		}
-
-		if (mActivePanel->hasFocus() && key == KEY_UP)
-		{
-			startSearch();
-		}
+    LLFolderView* root_folder = mActivePanel ? mActivePanel->getRootFolder() : NULL;
+    if (root_folder)
+    {
+        // first check for user accepting current search results
+        if (mFilterEditor
+            && mFilterEditor->hasFocus()
+            && (key == KEY_RETURN
+                || key == KEY_DOWN)
+            && mask == MASK_NONE)
+        {
+            // move focus to inventory proper
+            mActivePanel->setFocus(true);
+            root_folder->scrollToShowSelection();
+            return true;
+        }
+
+        if (mActivePanel->hasFocus() && key == KEY_UP)
+        {
+            startSearch();
+        }
         if(mSingleFolderMode && key == KEY_LEFT)
         {
             onBackFolderClicked();
         }
-	}
+    }
 
-	return LLPanel::handleKeyHere(key, mask);
+    return LLPanel::handleKeyHere(key, mask);
 
 }
 
@@ -421,12 +421,12 @@ bool LLPanelMainInventory::handleKeyHere(KEY key, MASK mask)
 
 void LLPanelMainInventory::doToSelected(const LLSD& userdata)
 {
-	getPanel()->doToSelected(userdata);
+    getPanel()->doToSelected(userdata);
 }
 
 void LLPanelMainInventory::closeAllFolders()
 {
-	getPanel()->getRootFolder()->closeAllFolders();
+    getPanel()->getRootFolder()->closeAllFolders();
 }
 
 S32 get_instance_num()
@@ -441,13 +441,13 @@ LLFloaterSidePanelContainer* LLPanelMainInventory::newWindow()
 {
     S32 instance_num = get_instance_num();
 
-	if (!gAgentCamera.cameraMouselook())
-	{
+    if (!gAgentCamera.cameraMouselook())
+    {
         LLFloaterSidePanelContainer* floater = LLFloaterReg::showTypedInstance<LLFloaterSidePanelContainer>("inventory", LLSD(instance_num));
         LLSidepanelInventory* sidepanel_inventory = floater->findChild<LLSidepanelInventory>("main_panel");
         sidepanel_inventory->initInventoryViews();
-		return floater;
-	}
+        return floater;
+    }
     return NULL;
 }
 
@@ -477,7 +477,7 @@ void LLPanelMainInventory::newFolderWindow(LLUUID folder_id, LLUUID item_to_sele
             }
         }
     }
-    
+
     S32 instance_num = get_instance_num();
 
     LLFloaterSidePanelContainer* inventory_container = LLFloaterReg::showTypedInstance<LLFloaterSidePanelContainer>("inventory", LLSD(instance_num));
@@ -505,7 +505,7 @@ void LLPanelMainInventory::newFolderWindow(LLUUID folder_id, LLUUID item_to_sele
 
 void LLPanelMainInventory::doCreate(const LLSD& userdata)
 {
-	reset_inventory_filter();
+    reset_inventory_filter();
     if(mSingleFolderMode)
     {
         if(isListViewMode() || isCombinationViewMode())
@@ -566,14 +566,14 @@ void LLPanelMainInventory::doCreate(const LLSD& userdata)
 
 void LLPanelMainInventory::resetFilters()
 {
-	LLFloaterInventoryFinder *finder = getFinder();
-	getCurrentFilter().resetDefault();
-	if (finder)
-	{
-		finder->updateElementsFromFilter();
-	}
+    LLFloaterInventoryFinder *finder = getFinder();
+    getCurrentFilter().resetDefault();
+    if (finder)
+    {
+        finder->updateElementsFromFilter();
+    }
 
-	setFilterTextFromFilter();
+    setFilterTextFromFilter();
 }
 
 void LLPanelMainInventory::resetAllItemsFilters()
@@ -601,44 +601,44 @@ void LLPanelMainInventory::findLinks(const LLUUID& item_id, const std::string& i
 
 void LLPanelMainInventory::setSortBy(const LLSD& userdata)
 {
-	U32 sort_order_mask = getActivePanel()->getSortOrder();
-	std::string sort_type = userdata.asString();
-	if (sort_type == "name")
-	{
-		sort_order_mask &= ~LLInventoryFilter::SO_DATE;
-	}
-	else if (sort_type == "date")
-	{
-		sort_order_mask |= LLInventoryFilter::SO_DATE;
-	}
-	else if (sort_type == "foldersalwaysbyname")
-	{
-		if ( sort_order_mask & LLInventoryFilter::SO_FOLDERS_BY_NAME )
-		{
-			sort_order_mask &= ~LLInventoryFilter::SO_FOLDERS_BY_NAME;
-		}
-		else
-		{
-			sort_order_mask |= LLInventoryFilter::SO_FOLDERS_BY_NAME;
-		}
-	}
-	else if (sort_type == "systemfolderstotop")
-	{
-		if ( sort_order_mask & LLInventoryFilter::SO_SYSTEM_FOLDERS_TO_TOP )
-		{
-			sort_order_mask &= ~LLInventoryFilter::SO_SYSTEM_FOLDERS_TO_TOP;
-		}
-		else
-		{
-			sort_order_mask |= LLInventoryFilter::SO_SYSTEM_FOLDERS_TO_TOP;
-		}
-	}
+    U32 sort_order_mask = getActivePanel()->getSortOrder();
+    std::string sort_type = userdata.asString();
+    if (sort_type == "name")
+    {
+        sort_order_mask &= ~LLInventoryFilter::SO_DATE;
+    }
+    else if (sort_type == "date")
+    {
+        sort_order_mask |= LLInventoryFilter::SO_DATE;
+    }
+    else if (sort_type == "foldersalwaysbyname")
+    {
+        if ( sort_order_mask & LLInventoryFilter::SO_FOLDERS_BY_NAME )
+        {
+            sort_order_mask &= ~LLInventoryFilter::SO_FOLDERS_BY_NAME;
+        }
+        else
+        {
+            sort_order_mask |= LLInventoryFilter::SO_FOLDERS_BY_NAME;
+        }
+    }
+    else if (sort_type == "systemfolderstotop")
+    {
+        if ( sort_order_mask & LLInventoryFilter::SO_SYSTEM_FOLDERS_TO_TOP )
+        {
+            sort_order_mask &= ~LLInventoryFilter::SO_SYSTEM_FOLDERS_TO_TOP;
+        }
+        else
+        {
+            sort_order_mask |= LLInventoryFilter::SO_SYSTEM_FOLDERS_TO_TOP;
+        }
+    }
     if(mSingleFolderMode && !isListViewMode())
     {
         mCombinationGalleryPanel->setSortOrder(sort_order_mask, true);
     }
 
-	getActivePanel()->setSortOrder(sort_order_mask);
+    getActivePanel()->setSortOrder(sort_order_mask);
     if (isRecentItemsPanelSelected())
     {
         gSavedSettings.setU32("RecentItemsSortOrder", sort_order_mask);
@@ -651,23 +651,23 @@ void LLPanelMainInventory::setSortBy(const LLSD& userdata)
 
 void LLPanelMainInventory::onSelectSearchType()
 {
-	std::string new_type = mSearchTypeCombo->getValue();
-	if (new_type == "search_by_name")
-	{
-		setSearchType(LLInventoryFilter::SEARCHTYPE_NAME);
-	}
-	if (new_type == "search_by_creator")
-	{
-		setSearchType(LLInventoryFilter::SEARCHTYPE_CREATOR);
-	}
-	if (new_type == "search_by_description")
-	{
-		setSearchType(LLInventoryFilter::SEARCHTYPE_DESCRIPTION);
-	}
-	if (new_type == "search_by_UUID")
-	{
-		setSearchType(LLInventoryFilter::SEARCHTYPE_UUID);
-	}
+    std::string new_type = mSearchTypeCombo->getValue();
+    if (new_type == "search_by_name")
+    {
+        setSearchType(LLInventoryFilter::SEARCHTYPE_NAME);
+    }
+    if (new_type == "search_by_creator")
+    {
+        setSearchType(LLInventoryFilter::SEARCHTYPE_CREATOR);
+    }
+    if (new_type == "search_by_description")
+    {
+        setSearchType(LLInventoryFilter::SEARCHTYPE_DESCRIPTION);
+    }
+    if (new_type == "search_by_UUID")
+    {
+        setSearchType(LLInventoryFilter::SEARCHTYPE_UUID);
+    }
 }
 
 void LLPanelMainInventory::setSearchType(LLInventoryFilter::ESearchType type)
@@ -704,70 +704,70 @@ void LLPanelMainInventory::updateSearchTypeCombo()
         search_type = getActivePanel()->getSearchType();
     }
 
-	switch(search_type)
-	{
-		case LLInventoryFilter::SEARCHTYPE_CREATOR:
-			mSearchTypeCombo->setValue("search_by_creator");
-			break;
-		case LLInventoryFilter::SEARCHTYPE_DESCRIPTION:
-			mSearchTypeCombo->setValue("search_by_description");
-			break;
-		case LLInventoryFilter::SEARCHTYPE_UUID:
-			mSearchTypeCombo->setValue("search_by_UUID");
-			break;
-		case LLInventoryFilter::SEARCHTYPE_NAME:
-		default:
-			mSearchTypeCombo->setValue("search_by_name");
-			break;
-	}
+    switch(search_type)
+    {
+        case LLInventoryFilter::SEARCHTYPE_CREATOR:
+            mSearchTypeCombo->setValue("search_by_creator");
+            break;
+        case LLInventoryFilter::SEARCHTYPE_DESCRIPTION:
+            mSearchTypeCombo->setValue("search_by_description");
+            break;
+        case LLInventoryFilter::SEARCHTYPE_UUID:
+            mSearchTypeCombo->setValue("search_by_UUID");
+            break;
+        case LLInventoryFilter::SEARCHTYPE_NAME:
+        default:
+            mSearchTypeCombo->setValue("search_by_name");
+            break;
+    }
 }
 
 // static
 bool LLPanelMainInventory::filtersVisible(void* user_data)
 {
-	LLPanelMainInventory* self = (LLPanelMainInventory*)user_data;
-	if(!self) return false;
+    LLPanelMainInventory* self = (LLPanelMainInventory*)user_data;
+    if(!self) return false;
 
-	return self->getFinder() != NULL;
+    return self->getFinder() != NULL;
 }
 
 void LLPanelMainInventory::onClearSearch()
 {
-	bool initially_active = false;
-	LLFloater *finder = getFinder();
-	if (mActivePanel && (getActivePanel() != mWornItemsPanel))
-	{
-		initially_active = mActivePanel->getFilter().isNotDefault();
-		setFilterSubString(LLStringUtil::null);
-		mActivePanel->setFilterTypes(0xffffffffffffffffULL);
-		mActivePanel->setFilterLinks(LLInventoryFilter::FILTERLINK_INCLUDE_LINKS);
-	}
-
-	if (finder)
-	{
-		LLFloaterInventoryFinder::selectAllTypes(finder);
-	}
-
-	// re-open folders that were initially open in case filter was active
-	if (mActivePanel && (mFilterSubString.size() || initially_active) && !mSingleFolderMode)
-	{
-		mSavedFolderState->setApply(true);
-		mActivePanel->getRootFolder()->applyFunctorRecursively(*mSavedFolderState);
-		LLOpenFoldersWithSelection opener;
-		mActivePanel->getRootFolder()->applyFunctorRecursively(opener);
-		mActivePanel->getRootFolder()->scrollToShowSelection();
-	}
-	mFilterSubString = "";
-
-	LLSidepanelInventory * sidepanel_inventory = getParentSidepanelInventory();
-	if (sidepanel_inventory)
-	{
-		LLPanelMarketplaceInbox* inbox_panel = sidepanel_inventory->getChild<LLPanelMarketplaceInbox>("marketplace_inbox");
-		if (inbox_panel)
-		{
-			inbox_panel->onClearSearch();
-		}
-	}
+    bool initially_active = false;
+    LLFloater *finder = getFinder();
+    if (mActivePanel && (getActivePanel() != mWornItemsPanel))
+    {
+        initially_active = mActivePanel->getFilter().isNotDefault();
+        setFilterSubString(LLStringUtil::null);
+        mActivePanel->setFilterTypes(0xffffffffffffffffULL);
+        mActivePanel->setFilterLinks(LLInventoryFilter::FILTERLINK_INCLUDE_LINKS);
+    }
+
+    if (finder)
+    {
+        LLFloaterInventoryFinder::selectAllTypes(finder);
+    }
+
+    // re-open folders that were initially open in case filter was active
+    if (mActivePanel && (mFilterSubString.size() || initially_active) && !mSingleFolderMode)
+    {
+        mSavedFolderState->setApply(true);
+        mActivePanel->getRootFolder()->applyFunctorRecursively(*mSavedFolderState);
+        LLOpenFoldersWithSelection opener;
+        mActivePanel->getRootFolder()->applyFunctorRecursively(opener);
+        mActivePanel->getRootFolder()->scrollToShowSelection();
+    }
+    mFilterSubString = "";
+
+    LLSidepanelInventory * sidepanel_inventory = getParentSidepanelInventory();
+    if (sidepanel_inventory)
+    {
+        LLPanelMarketplaceInbox* inbox_panel = sidepanel_inventory->getChild<LLPanelMarketplaceInbox>("marketplace_inbox");
+        if (inbox_panel)
+        {
+            inbox_panel->onClearSearch();
+        }
+    }
 }
 
 void LLPanelMainInventory::onFilterEdit(const std::string& search_string )
@@ -783,15 +783,15 @@ void LLPanelMainInventory::onFilterEdit(const std::string& search_string )
         mCombinationGalleryPanel->setFilterSubString(search_string);
     }
 
-	if (search_string == "")
-	{
-		onClearSearch();
-	}
+    if (search_string == "")
+    {
+        onClearSearch();
+    }
 
-	if (!mActivePanel)
-	{
-		return;
-	}
+    if (!mActivePanel)
+    {
+        return;
+    }
 
     if (!LLInventoryModelBackgroundFetch::instance().inventoryFetchStarted())
     {
@@ -799,215 +799,215 @@ void LLPanelMainInventory::onFilterEdit(const std::string& search_string )
         LLInventoryModelBackgroundFetch::instance().start();
     }
 
-	mFilterSubString = search_string;
-	if (mActivePanel->getFilterSubString().empty() && mFilterSubString.empty())
-	{
-			// current filter and new filter empty, do nothing
-			return;
-	}
+    mFilterSubString = search_string;
+    if (mActivePanel->getFilterSubString().empty() && mFilterSubString.empty())
+    {
+            // current filter and new filter empty, do nothing
+            return;
+    }
 
-	// save current folder open state if no filter currently applied
-	if (!mActivePanel->getFilter().isNotDefault())
-	{
-		mSavedFolderState->setApply(false);
-		mActivePanel->getRootFolder()->applyFunctorRecursively(*mSavedFolderState);
-	}
+    // save current folder open state if no filter currently applied
+    if (!mActivePanel->getFilter().isNotDefault())
+    {
+        mSavedFolderState->setApply(false);
+        mActivePanel->getRootFolder()->applyFunctorRecursively(*mSavedFolderState);
+    }
 
-	// set new filter string
-	setFilterSubString(mFilterSubString);
+    // set new filter string
+    setFilterSubString(mFilterSubString);
 
     LLSidepanelInventory * sidepanel_inventory = getParentSidepanelInventory();
-	if (sidepanel_inventory)
-	{
-		LLPanelMarketplaceInbox* inbox_panel = sidepanel_inventory->getChild<LLPanelMarketplaceInbox>("marketplace_inbox");
-		if (inbox_panel)
-		{
-			inbox_panel->onFilterEdit(search_string);
-		}
-	}
+    if (sidepanel_inventory)
+    {
+        LLPanelMarketplaceInbox* inbox_panel = sidepanel_inventory->getChild<LLPanelMarketplaceInbox>("marketplace_inbox");
+        if (inbox_panel)
+        {
+            inbox_panel->onFilterEdit(search_string);
+        }
+    }
 }
 
 
  //static
  bool LLPanelMainInventory::incrementalFind(LLFolderViewItem* first_item, const char *find_text, bool backward)
  {
- 	LLPanelMainInventory* active_view = NULL;
-	
-	LLFloaterReg::const_instance_list_t& inst_list = LLFloaterReg::getFloaterList("inventory");
-	for (LLFloaterReg::const_instance_list_t::const_iterator iter = inst_list.begin(); iter != inst_list.end(); ++iter)
-	{
-		LLPanelMainInventory* iv = dynamic_cast<LLPanelMainInventory*>(*iter);
-		if (iv)
-		{
-			if (gFocusMgr.childHasKeyboardFocus(iv))
-			{
-				active_view = iv;
-				break;
-			}
- 		}
- 	}
-
- 	if (!active_view)
- 	{
- 		return false;
- 	}
-
- 	std::string search_string(find_text);
-
- 	if (search_string.empty())
- 	{
- 		return false;
- 	}
-
- 	if (active_view->getPanel() &&
- 		active_view->getPanel()->getRootFolder()->search(first_item, search_string, backward))
- 	{
- 		return true;
- 	}
-
- 	return false;
+    LLPanelMainInventory* active_view = NULL;
+
+    LLFloaterReg::const_instance_list_t& inst_list = LLFloaterReg::getFloaterList("inventory");
+    for (LLFloaterReg::const_instance_list_t::const_iterator iter = inst_list.begin(); iter != inst_list.end(); ++iter)
+    {
+        LLPanelMainInventory* iv = dynamic_cast<LLPanelMainInventory*>(*iter);
+        if (iv)
+        {
+            if (gFocusMgr.childHasKeyboardFocus(iv))
+            {
+                active_view = iv;
+                break;
+            }
+        }
+    }
+
+    if (!active_view)
+    {
+        return false;
+    }
+
+    std::string search_string(find_text);
+
+    if (search_string.empty())
+    {
+        return false;
+    }
+
+    if (active_view->getPanel() &&
+        active_view->getPanel()->getRootFolder()->search(first_item, search_string, backward))
+    {
+        return true;
+    }
+
+    return false;
  }
 
 void LLPanelMainInventory::onFilterSelected()
 {
-	// Find my index
+    // Find my index
     setActivePanel();
 
-	if (!mActivePanel)
-	{
-		return;
-	}
-
-	if (getActivePanel() == mWornItemsPanel)
-	{
-		mActivePanel->openAllFolders();
-	}
-	updateSearchTypeCombo();
-	setFilterSubString(mFilterSubString);
-	LLInventoryFilter& filter = getCurrentFilter();
-	LLFloaterInventoryFinder *finder = getFinder();
-	if (finder)
-	{
-		finder->changeFilter(&filter);
+    if (!mActivePanel)
+    {
+        return;
+    }
+
+    if (getActivePanel() == mWornItemsPanel)
+    {
+        mActivePanel->openAllFolders();
+    }
+    updateSearchTypeCombo();
+    setFilterSubString(mFilterSubString);
+    LLInventoryFilter& filter = getCurrentFilter();
+    LLFloaterInventoryFinder *finder = getFinder();
+    if (finder)
+    {
+        finder->changeFilter(&filter);
         if (mSingleFolderMode)
         {
             finder->setTitle(getLocalizedRootName());
         }
-	}
-	if (filter.isActive() && !LLInventoryModelBackgroundFetch::instance().inventoryFetchStarted())
-	{
+    }
+    if (filter.isActive() && !LLInventoryModelBackgroundFetch::instance().inventoryFetchStarted())
+    {
         llassert(false); // this should have been done on startup
-		LLInventoryModelBackgroundFetch::instance().start();
-	}
-	setFilterTextFromFilter();
+        LLInventoryModelBackgroundFetch::instance().start();
+    }
+    setFilterTextFromFilter();
 }
 
-const std::string LLPanelMainInventory::getFilterSubString() 
-{ 
-	return mActivePanel->getFilterSubString(); 
+const std::string LLPanelMainInventory::getFilterSubString()
+{
+    return mActivePanel->getFilterSubString();
 }
 
-void LLPanelMainInventory::setFilterSubString(const std::string& string) 
-{ 
-	mActivePanel->setFilterSubString(string); 
+void LLPanelMainInventory::setFilterSubString(const std::string& string)
+{
+    mActivePanel->setFilterSubString(string);
 }
 
 bool LLPanelMainInventory::handleDragAndDrop(S32 x, S32 y, MASK mask, bool drop,
-										 EDragAndDropType cargo_type,
-										 void* cargo_data,
-										 EAcceptance* accept,
-										 std::string& tooltip_msg)
-{
-	// Check to see if we are auto scrolling from the last frame
-	LLInventoryPanel* panel = (LLInventoryPanel*)this->getActivePanel();
-	bool needsToScroll = panel->getScrollableContainer()->canAutoScroll(x, y);
-	if(mFilterTabs)
-	{
-		if(needsToScroll)
-		{
-			mFilterTabs->startDragAndDropDelayTimer();
-		}
-	}
-	
-	bool handled = LLPanel::handleDragAndDrop(x, y, mask, drop, cargo_type, cargo_data, accept, tooltip_msg);
-
-	return handled;
+                                         EDragAndDropType cargo_type,
+                                         void* cargo_data,
+                                         EAcceptance* accept,
+                                         std::string& tooltip_msg)
+{
+    // Check to see if we are auto scrolling from the last frame
+    LLInventoryPanel* panel = (LLInventoryPanel*)this->getActivePanel();
+    bool needsToScroll = panel->getScrollableContainer()->canAutoScroll(x, y);
+    if(mFilterTabs)
+    {
+        if(needsToScroll)
+        {
+            mFilterTabs->startDragAndDropDelayTimer();
+        }
+    }
+
+    bool handled = LLPanel::handleDragAndDrop(x, y, mask, drop, cargo_type, cargo_data, accept, tooltip_msg);
+
+    return handled;
 }
 
 // virtual
 void LLPanelMainInventory::changed(U32)
 {
-	updateItemcountText();
+    updateItemcountText();
 }
 
 void LLPanelMainInventory::setFocusFilterEditor()
 {
-	if(mFilterEditor)
-	{
-		mFilterEditor->setFocus(true);
-	}
+    if(mFilterEditor)
+    {
+        mFilterEditor->setFocus(true);
+    }
 }
 
 // virtual
 void LLPanelMainInventory::draw()
 {
-	if (mActivePanel && mFilterEditor)
-	{
-		mFilterEditor->setText(mFilterSubString);
-	}	
-	if (mActivePanel && mResortActivePanel)
-	{
-		// EXP-756: Force resorting of the list the first time we draw the list: 
-		// In the case of date sorting, we don't have enough information at initialization time
-		// to correctly sort the folders. Later manual resort doesn't do anything as the order value is 
-		// set correctly. The workaround is to reset the order to alphabetical (or anything) then to the correct order.
-		U32 order = mActivePanel->getSortOrder();
-		mActivePanel->setSortOrder(LLInventoryFilter::SO_NAME);
-		mActivePanel->setSortOrder(order);
-		mResortActivePanel = false;
-	}
-	LLPanel::draw();
-	updateItemcountText();
+    if (mActivePanel && mFilterEditor)
+    {
+        mFilterEditor->setText(mFilterSubString);
+    }
+    if (mActivePanel && mResortActivePanel)
+    {
+        // EXP-756: Force resorting of the list the first time we draw the list:
+        // In the case of date sorting, we don't have enough information at initialization time
+        // to correctly sort the folders. Later manual resort doesn't do anything as the order value is
+        // set correctly. The workaround is to reset the order to alphabetical (or anything) then to the correct order.
+        U32 order = mActivePanel->getSortOrder();
+        mActivePanel->setSortOrder(LLInventoryFilter::SO_NAME);
+        mActivePanel->setSortOrder(order);
+        mResortActivePanel = false;
+    }
+    LLPanel::draw();
+    updateItemcountText();
     updateCombinationVisibility();
 }
 
 void LLPanelMainInventory::updateItemcountText()
 {
-	if(mItemCount != gInventory.getItemCount())
-	{
-		mItemCount = gInventory.getItemCount();
-		mItemCountString = "";
-		LLLocale locale(LLLocale::USER_LOCALE);
-		LLResMgr::getInstance()->getIntegerString(mItemCountString, mItemCount);
-	}
-
-	if(mCategoryCount != gInventory.getCategoryCount())
-	{
-		mCategoryCount = gInventory.getCategoryCount();
-		mCategoryCountString = "";
-		LLLocale locale(LLLocale::USER_LOCALE);
-		LLResMgr::getInstance()->getIntegerString(mCategoryCountString, mCategoryCount);
-	}
-
-	LLStringUtil::format_map_t string_args;
-	string_args["[ITEM_COUNT]"] = mItemCountString;
-	string_args["[CATEGORY_COUNT]"] = mCategoryCountString;
-	string_args["[FILTER]"] = getFilterText();
-
-	std::string text = "";
-
-	if (LLInventoryModelBackgroundFetch::instance().folderFetchActive())
-	{
-		text = getString("ItemcountFetching", string_args);
-	}
-	else if (LLInventoryModelBackgroundFetch::instance().isEverythingFetched())
-	{
-		text = getString("ItemcountCompleted", string_args);
-	}
-	else
-	{
-		text = getString("ItemcountUnknown", string_args);
-	}
+    if(mItemCount != gInventory.getItemCount())
+    {
+        mItemCount = gInventory.getItemCount();
+        mItemCountString = "";
+        LLLocale locale(LLLocale::USER_LOCALE);
+        LLResMgr::getInstance()->getIntegerString(mItemCountString, mItemCount);
+    }
+
+    if(mCategoryCount != gInventory.getCategoryCount())
+    {
+        mCategoryCount = gInventory.getCategoryCount();
+        mCategoryCountString = "";
+        LLLocale locale(LLLocale::USER_LOCALE);
+        LLResMgr::getInstance()->getIntegerString(mCategoryCountString, mCategoryCount);
+    }
+
+    LLStringUtil::format_map_t string_args;
+    string_args["[ITEM_COUNT]"] = mItemCountString;
+    string_args["[CATEGORY_COUNT]"] = mCategoryCountString;
+    string_args["[FILTER]"] = getFilterText();
+
+    std::string text = "";
+
+    if (LLInventoryModelBackgroundFetch::instance().folderFetchActive())
+    {
+        text = getString("ItemcountFetching", string_args);
+    }
+    else if (LLInventoryModelBackgroundFetch::instance().isEverythingFetched())
+    {
+        text = getString("ItemcountCompleted", string_args);
+    }
+    else
+    {
+        text = getString("ItemcountUnknown", string_args);
+    }
 
     if (mSingleFolderMode)
     {
@@ -1023,40 +1023,40 @@ void LLPanelMainInventory::updateItemcountText()
             text = getString("ItemcountCompleted", string_args);
         }
     }
-	
+
     mCounterCtrl->setValue(text);
     mCounterCtrl->setToolTip(text);
 }
 
 void LLPanelMainInventory::onFocusReceived()
 {
-	LLSidepanelInventory *sidepanel_inventory =	LLFloaterSidePanelContainer::getPanel<LLSidepanelInventory>("inventory");
-	if (!sidepanel_inventory)
-	{
-		LL_WARNS() << "Could not find Inventory Panel in My Inventory floater" << LL_ENDL;
-		return;
-	}
+    LLSidepanelInventory *sidepanel_inventory = LLFloaterSidePanelContainer::getPanel<LLSidepanelInventory>("inventory");
+    if (!sidepanel_inventory)
+    {
+        LL_WARNS() << "Could not find Inventory Panel in My Inventory floater" << LL_ENDL;
+        return;
+    }
 
-	sidepanel_inventory->clearSelections(false, true);
+    sidepanel_inventory->clearSelections(false, true);
 }
 
-void LLPanelMainInventory::setFilterTextFromFilter() 
-{ 
-	mFilterText = getCurrentFilter().getFilterText();
+void LLPanelMainInventory::setFilterTextFromFilter()
+{
+    mFilterText = getCurrentFilter().getFilterText();
 }
 
 void LLPanelMainInventory::toggleFindOptions()
 {
-	LLFloater *floater = getFinder();
-	if (!floater)
-	{
-		LLFloaterInventoryFinder * finder = new LLFloaterInventoryFinder(this);
-		mFinderHandle = finder->getHandle();
-		finder->openFloater();
+    LLFloater *floater = getFinder();
+    if (!floater)
+    {
+        LLFloaterInventoryFinder * finder = new LLFloaterInventoryFinder(this);
+        mFinderHandle = finder->getHandle();
+        finder->openFloater();
 
-		LLFloater* parent_floater = gFloaterView->getParentFloater(this);
-		if (parent_floater)
-			parent_floater->addDependentFloater(mFinderHandle);
+        LLFloater* parent_floater = gFloaterView->getParentFloater(this);
+        if (parent_floater)
+            parent_floater->addDependentFloater(mFinderHandle);
 
         if (!LLInventoryModelBackgroundFetch::instance().inventoryFetchStarted())
         {
@@ -1068,232 +1068,232 @@ void LLPanelMainInventory::toggleFindOptions()
         {
             finder->setTitle(getLocalizedRootName());
         }
-	}
-	else
-	{
-		floater->closeFloater();
-	}
+    }
+    else
+    {
+        floater->closeFloater();
+    }
 }
 
 void LLPanelMainInventory::setSelectCallback(const LLFolderView::signal_t::slot_type& cb)
 {
-	getChild<LLInventoryPanel>(ALL_ITEMS)->setSelectCallback(cb);
-	getChild<LLInventoryPanel>(RECENT_ITEMS)->setSelectCallback(cb);
+    getChild<LLInventoryPanel>(ALL_ITEMS)->setSelectCallback(cb);
+    getChild<LLInventoryPanel>(RECENT_ITEMS)->setSelectCallback(cb);
 }
 
 void LLPanelMainInventory::onSelectionChange(LLInventoryPanel *panel, const std::deque<LLFolderViewItem*>& items, bool user_action)
 {
-	updateListCommands();
-	panel->onSelectionChange(items, user_action);
+    updateListCommands();
+    panel->onSelectionChange(items, user_action);
 }
 
 ///----------------------------------------------------------------------------
 /// LLFloaterInventoryFinder
 ///----------------------------------------------------------------------------
 
-LLFloaterInventoryFinder* LLPanelMainInventory::getFinder() 
-{ 
-	return (LLFloaterInventoryFinder*)mFinderHandle.get();
+LLFloaterInventoryFinder* LLPanelMainInventory::getFinder()
+{
+    return (LLFloaterInventoryFinder*)mFinderHandle.get();
 }
 
 
-LLFloaterInventoryFinder::LLFloaterInventoryFinder(LLPanelMainInventory* inventory_view) :	
-	LLFloater(LLSD()),
-	mPanelMainInventory(inventory_view),
-	mFilter(&inventory_view->getPanel()->getFilter())
+LLFloaterInventoryFinder::LLFloaterInventoryFinder(LLPanelMainInventory* inventory_view) :
+    LLFloater(LLSD()),
+    mPanelMainInventory(inventory_view),
+    mFilter(&inventory_view->getPanel()->getFilter())
 {
-	buildFromFile("floater_inventory_view_finder.xml");
-	updateElementsFromFilter();
+    buildFromFile("floater_inventory_view_finder.xml");
+    updateElementsFromFilter();
 }
 
 bool LLFloaterInventoryFinder::postBuild()
 {
-	const LLRect& viewrect = mPanelMainInventory->getRect();
-	setRect(LLRect(viewrect.mLeft - getRect().getWidth(), viewrect.mTop, viewrect.mLeft, viewrect.mTop - getRect().getHeight()));
+    const LLRect& viewrect = mPanelMainInventory->getRect();
+    setRect(LLRect(viewrect.mLeft - getRect().getWidth(), viewrect.mTop, viewrect.mLeft, viewrect.mTop - getRect().getHeight()));
 
-	childSetAction("All", selectAllTypes, this);
-	childSetAction("None", selectNoTypes, this);
+    childSetAction("All", selectAllTypes, this);
+    childSetAction("None", selectNoTypes, this);
 
-	mSpinSinceHours = getChild<LLSpinCtrl>("spin_hours_ago");
-	childSetCommitCallback("spin_hours_ago", onTimeAgo, this);
+    mSpinSinceHours = getChild<LLSpinCtrl>("spin_hours_ago");
+    childSetCommitCallback("spin_hours_ago", onTimeAgo, this);
 
-	mSpinSinceDays = getChild<LLSpinCtrl>("spin_days_ago");
-	childSetCommitCallback("spin_days_ago", onTimeAgo, this);
+    mSpinSinceDays = getChild<LLSpinCtrl>("spin_days_ago");
+    childSetCommitCallback("spin_days_ago", onTimeAgo, this);
 
-	mCreatorSelf = getChild<LLCheckBoxCtrl>("check_created_by_me");
-	mCreatorOthers = getChild<LLCheckBoxCtrl>("check_created_by_others");
-	mCreatorSelf->setCommitCallback(boost::bind(&LLFloaterInventoryFinder::onCreatorSelfFilterCommit, this));
-	mCreatorOthers->setCommitCallback(boost::bind(&LLFloaterInventoryFinder::onCreatorOtherFilterCommit, this));
+    mCreatorSelf = getChild<LLCheckBoxCtrl>("check_created_by_me");
+    mCreatorOthers = getChild<LLCheckBoxCtrl>("check_created_by_others");
+    mCreatorSelf->setCommitCallback(boost::bind(&LLFloaterInventoryFinder::onCreatorSelfFilterCommit, this));
+    mCreatorOthers->setCommitCallback(boost::bind(&LLFloaterInventoryFinder::onCreatorOtherFilterCommit, this));
 
-	childSetAction("Close", onCloseBtn, this);
+    childSetAction("Close", onCloseBtn, this);
 
-	updateElementsFromFilter();
-	return true;
+    updateElementsFromFilter();
+    return true;
 }
 void LLFloaterInventoryFinder::onTimeAgo(LLUICtrl *ctrl, void *user_data)
 {
-	LLFloaterInventoryFinder *self = (LLFloaterInventoryFinder *)user_data;
-	if (!self) return;
-	
-	if ( self->mSpinSinceDays->get() ||  self->mSpinSinceHours->get() )
-	{
-		self->getChild<LLUICtrl>("check_since_logoff")->setValue(false);
-
-		U32 days = (U32)self->mSpinSinceDays->get();
-		U32 hours = (U32)self->mSpinSinceHours->get();
-		if (hours >= 24)
-		{
-			// Try to handle both cases of spinner clicking and text input in a sensible fashion as best as possible.
-			// There is no way to tell if someone has clicked the spinner to get to 24 or input 24 manually, so in
-			// this case add to days.  Any value > 24 means they have input the hours manually, so do not add to the
-			// current day value.
-			if (24 == hours)  // Got to 24 via spinner clicking or text input of 24
-			{
-				days = days + hours / 24;
-			}
-			else	// Text input, so do not add to days
-			{ 
-				days = hours / 24;
-			}
-			hours = (U32)hours % 24;
-			self->mSpinSinceHours->setFocus(false);
-			self->mSpinSinceDays->setFocus(false);
-			self->mSpinSinceDays->set((F32)days);
-			self->mSpinSinceHours->set((F32)hours);
-			self->mSpinSinceHours->setFocus(true);
-		}
-	}
+    LLFloaterInventoryFinder *self = (LLFloaterInventoryFinder *)user_data;
+    if (!self) return;
+
+    if ( self->mSpinSinceDays->get() ||  self->mSpinSinceHours->get() )
+    {
+        self->getChild<LLUICtrl>("check_since_logoff")->setValue(false);
+
+        U32 days = (U32)self->mSpinSinceDays->get();
+        U32 hours = (U32)self->mSpinSinceHours->get();
+        if (hours >= 24)
+        {
+            // Try to handle both cases of spinner clicking and text input in a sensible fashion as best as possible.
+            // There is no way to tell if someone has clicked the spinner to get to 24 or input 24 manually, so in
+            // this case add to days.  Any value > 24 means they have input the hours manually, so do not add to the
+            // current day value.
+            if (24 == hours)  // Got to 24 via spinner clicking or text input of 24
+            {
+                days = days + hours / 24;
+            }
+            else    // Text input, so do not add to days
+            {
+                days = hours / 24;
+            }
+            hours = (U32)hours % 24;
+            self->mSpinSinceHours->setFocus(false);
+            self->mSpinSinceDays->setFocus(false);
+            self->mSpinSinceDays->set((F32)days);
+            self->mSpinSinceHours->set((F32)hours);
+            self->mSpinSinceHours->setFocus(true);
+        }
+    }
 }
 
 void LLFloaterInventoryFinder::changeFilter(LLInventoryFilter* filter)
 {
-	mFilter = filter;
-	updateElementsFromFilter();
+    mFilter = filter;
+    updateElementsFromFilter();
 }
 
 void LLFloaterInventoryFinder::updateElementsFromFilter()
 {
-	if (!mFilter)
-		return;
-
-	// Get data needed for filter display
-	U32 filter_types = mFilter->getFilterObjectTypes();
-	LLInventoryFilter::EFolderShow show_folders = mFilter->getShowFolderState();
-	U32 hours = mFilter->getHoursAgo();
-	U32 date_search_direction = mFilter->getDateSearchDirection();
-
-	LLInventoryFilter::EFilterCreatorType filter_creator = mFilter->getFilterCreatorType();
-	bool show_created_by_me = ((filter_creator == LLInventoryFilter::FILTERCREATOR_ALL) || (filter_creator == LLInventoryFilter::FILTERCREATOR_SELF));
-	bool show_created_by_others = ((filter_creator == LLInventoryFilter::FILTERCREATOR_ALL) || (filter_creator == LLInventoryFilter::FILTERCREATOR_OTHERS));
-
-	// update the ui elements
-	setTitle(mFilter->getName());
-
-	getChild<LLUICtrl>("check_animation")->setValue((S32) (filter_types & 0x1 << LLInventoryType::IT_ANIMATION));
-
-	getChild<LLUICtrl>("check_calling_card")->setValue((S32) (filter_types & 0x1 << LLInventoryType::IT_CALLINGCARD));
-	getChild<LLUICtrl>("check_clothing")->setValue((S32) (filter_types & 0x1 << LLInventoryType::IT_WEARABLE));
-	getChild<LLUICtrl>("check_gesture")->setValue((S32) (filter_types & 0x1 << LLInventoryType::IT_GESTURE));
-	getChild<LLUICtrl>("check_landmark")->setValue((S32) (filter_types & 0x1 << LLInventoryType::IT_LANDMARK));
-	getChild<LLUICtrl>("check_material")->setValue((S32) (filter_types & 0x1 << LLInventoryType::IT_MATERIAL));
-	getChild<LLUICtrl>("check_notecard")->setValue((S32) (filter_types & 0x1 << LLInventoryType::IT_NOTECARD));
-	getChild<LLUICtrl>("check_object")->setValue((S32) (filter_types & 0x1 << LLInventoryType::IT_OBJECT));
-	getChild<LLUICtrl>("check_script")->setValue((S32) (filter_types & 0x1 << LLInventoryType::IT_LSL));
-	getChild<LLUICtrl>("check_sound")->setValue((S32) (filter_types & 0x1 << LLInventoryType::IT_SOUND));
-	getChild<LLUICtrl>("check_texture")->setValue((S32) (filter_types & 0x1 << LLInventoryType::IT_TEXTURE));
-	getChild<LLUICtrl>("check_snapshot")->setValue((S32) (filter_types & 0x1 << LLInventoryType::IT_SNAPSHOT));
+    if (!mFilter)
+        return;
+
+    // Get data needed for filter display
+    U32 filter_types = mFilter->getFilterObjectTypes();
+    LLInventoryFilter::EFolderShow show_folders = mFilter->getShowFolderState();
+    U32 hours = mFilter->getHoursAgo();
+    U32 date_search_direction = mFilter->getDateSearchDirection();
+
+    LLInventoryFilter::EFilterCreatorType filter_creator = mFilter->getFilterCreatorType();
+    bool show_created_by_me = ((filter_creator == LLInventoryFilter::FILTERCREATOR_ALL) || (filter_creator == LLInventoryFilter::FILTERCREATOR_SELF));
+    bool show_created_by_others = ((filter_creator == LLInventoryFilter::FILTERCREATOR_ALL) || (filter_creator == LLInventoryFilter::FILTERCREATOR_OTHERS));
+
+    // update the ui elements
+    setTitle(mFilter->getName());
+
+    getChild<LLUICtrl>("check_animation")->setValue((S32) (filter_types & 0x1 << LLInventoryType::IT_ANIMATION));
+
+    getChild<LLUICtrl>("check_calling_card")->setValue((S32) (filter_types & 0x1 << LLInventoryType::IT_CALLINGCARD));
+    getChild<LLUICtrl>("check_clothing")->setValue((S32) (filter_types & 0x1 << LLInventoryType::IT_WEARABLE));
+    getChild<LLUICtrl>("check_gesture")->setValue((S32) (filter_types & 0x1 << LLInventoryType::IT_GESTURE));
+    getChild<LLUICtrl>("check_landmark")->setValue((S32) (filter_types & 0x1 << LLInventoryType::IT_LANDMARK));
+    getChild<LLUICtrl>("check_material")->setValue((S32) (filter_types & 0x1 << LLInventoryType::IT_MATERIAL));
+    getChild<LLUICtrl>("check_notecard")->setValue((S32) (filter_types & 0x1 << LLInventoryType::IT_NOTECARD));
+    getChild<LLUICtrl>("check_object")->setValue((S32) (filter_types & 0x1 << LLInventoryType::IT_OBJECT));
+    getChild<LLUICtrl>("check_script")->setValue((S32) (filter_types & 0x1 << LLInventoryType::IT_LSL));
+    getChild<LLUICtrl>("check_sound")->setValue((S32) (filter_types & 0x1 << LLInventoryType::IT_SOUND));
+    getChild<LLUICtrl>("check_texture")->setValue((S32) (filter_types & 0x1 << LLInventoryType::IT_TEXTURE));
+    getChild<LLUICtrl>("check_snapshot")->setValue((S32) (filter_types & 0x1 << LLInventoryType::IT_SNAPSHOT));
     getChild<LLUICtrl>("check_settings")->setValue((S32)(filter_types & 0x1 << LLInventoryType::IT_SETTINGS));
-	getChild<LLUICtrl>("check_show_empty")->setValue(show_folders == LLInventoryFilter::SHOW_ALL_FOLDERS);
+    getChild<LLUICtrl>("check_show_empty")->setValue(show_folders == LLInventoryFilter::SHOW_ALL_FOLDERS);
 
-	getChild<LLUICtrl>("check_created_by_me")->setValue(show_created_by_me);
-	getChild<LLUICtrl>("check_created_by_others")->setValue(show_created_by_others);
+    getChild<LLUICtrl>("check_created_by_me")->setValue(show_created_by_me);
+    getChild<LLUICtrl>("check_created_by_others")->setValue(show_created_by_others);
 
-	getChild<LLUICtrl>("check_since_logoff")->setValue(mFilter->isSinceLogoff());
-	mSpinSinceHours->set((F32)(hours % 24));
-	mSpinSinceDays->set((F32)(hours / 24));
-	getChild<LLRadioGroup>("date_search_direction")->setSelectedIndex(date_search_direction);
+    getChild<LLUICtrl>("check_since_logoff")->setValue(mFilter->isSinceLogoff());
+    mSpinSinceHours->set((F32)(hours % 24));
+    mSpinSinceDays->set((F32)(hours / 24));
+    getChild<LLRadioGroup>("date_search_direction")->setSelectedIndex(date_search_direction);
 }
 
 void LLFloaterInventoryFinder::draw()
 {
-	U64 filter = 0xffffffffffffffffULL;
-	bool filtered_by_all_types = true;
-
-	if (!getChild<LLUICtrl>("check_animation")->getValue())
-	{
-		filter &= ~(0x1 << LLInventoryType::IT_ANIMATION);
-		filtered_by_all_types = false;
-	}
-
-
-	if (!getChild<LLUICtrl>("check_calling_card")->getValue())
-	{
-		filter &= ~(0x1 << LLInventoryType::IT_CALLINGCARD);
-		filtered_by_all_types = false;
-	}
-
-	if (!getChild<LLUICtrl>("check_clothing")->getValue())
-	{
-		filter &= ~(0x1 << LLInventoryType::IT_WEARABLE);
-		filtered_by_all_types = false;
-	}
-
-	if (!getChild<LLUICtrl>("check_gesture")->getValue())
-	{
-		filter &= ~(0x1 << LLInventoryType::IT_GESTURE);
-		filtered_by_all_types = false;
-	}
-
-	if (!getChild<LLUICtrl>("check_landmark")->getValue())
-
-
-	{
-		filter &= ~(0x1 << LLInventoryType::IT_LANDMARK);
-		filtered_by_all_types = false;
-	}
-
-	if (!getChild<LLUICtrl>("check_material")->getValue())
-	{
-		filter &= ~(0x1 << LLInventoryType::IT_MATERIAL);
-		filtered_by_all_types = false;
-	}
-
-	if (!getChild<LLUICtrl>("check_notecard")->getValue())
-	{
-		filter &= ~(0x1 << LLInventoryType::IT_NOTECARD);
-		filtered_by_all_types = false;
-	}
-
-	if (!getChild<LLUICtrl>("check_object")->getValue())
-	{
-		filter &= ~(0x1 << LLInventoryType::IT_OBJECT);
-		filter &= ~(0x1 << LLInventoryType::IT_ATTACHMENT);
-		filtered_by_all_types = false;
-	}
-
-	if (!getChild<LLUICtrl>("check_script")->getValue())
-	{
-		filter &= ~(0x1 << LLInventoryType::IT_LSL);
-		filtered_by_all_types = false;
-	}
-
-	if (!getChild<LLUICtrl>("check_sound")->getValue())
-	{
-		filter &= ~(0x1 << LLInventoryType::IT_SOUND);
-		filtered_by_all_types = false;
-	}
-
-	if (!getChild<LLUICtrl>("check_texture")->getValue())
-	{
-		filter &= ~(0x1 << LLInventoryType::IT_TEXTURE);
-		filtered_by_all_types = false;
-	}
-
-	if (!getChild<LLUICtrl>("check_snapshot")->getValue())
-	{
-		filter &= ~(0x1 << LLInventoryType::IT_SNAPSHOT);
-		filtered_by_all_types = false;
-	}
+    U64 filter = 0xffffffffffffffffULL;
+    bool filtered_by_all_types = true;
+
+    if (!getChild<LLUICtrl>("check_animation")->getValue())
+    {
+        filter &= ~(0x1 << LLInventoryType::IT_ANIMATION);
+        filtered_by_all_types = false;
+    }
+
+
+    if (!getChild<LLUICtrl>("check_calling_card")->getValue())
+    {
+        filter &= ~(0x1 << LLInventoryType::IT_CALLINGCARD);
+        filtered_by_all_types = false;
+    }
+
+    if (!getChild<LLUICtrl>("check_clothing")->getValue())
+    {
+        filter &= ~(0x1 << LLInventoryType::IT_WEARABLE);
+        filtered_by_all_types = false;
+    }
+
+    if (!getChild<LLUICtrl>("check_gesture")->getValue())
+    {
+        filter &= ~(0x1 << LLInventoryType::IT_GESTURE);
+        filtered_by_all_types = false;
+    }
+
+    if (!getChild<LLUICtrl>("check_landmark")->getValue())
+
+
+    {
+        filter &= ~(0x1 << LLInventoryType::IT_LANDMARK);
+        filtered_by_all_types = false;
+    }
+
+    if (!getChild<LLUICtrl>("check_material")->getValue())
+    {
+        filter &= ~(0x1 << LLInventoryType::IT_MATERIAL);
+        filtered_by_all_types = false;
+    }
+
+    if (!getChild<LLUICtrl>("check_notecard")->getValue())
+    {
+        filter &= ~(0x1 << LLInventoryType::IT_NOTECARD);
+        filtered_by_all_types = false;
+    }
+
+    if (!getChild<LLUICtrl>("check_object")->getValue())
+    {
+        filter &= ~(0x1 << LLInventoryType::IT_OBJECT);
+        filter &= ~(0x1 << LLInventoryType::IT_ATTACHMENT);
+        filtered_by_all_types = false;
+    }
+
+    if (!getChild<LLUICtrl>("check_script")->getValue())
+    {
+        filter &= ~(0x1 << LLInventoryType::IT_LSL);
+        filtered_by_all_types = false;
+    }
+
+    if (!getChild<LLUICtrl>("check_sound")->getValue())
+    {
+        filter &= ~(0x1 << LLInventoryType::IT_SOUND);
+        filtered_by_all_types = false;
+    }
+
+    if (!getChild<LLUICtrl>("check_texture")->getValue())
+    {
+        filter &= ~(0x1 << LLInventoryType::IT_TEXTURE);
+        filtered_by_all_types = false;
+    }
+
+    if (!getChild<LLUICtrl>("check_snapshot")->getValue())
+    {
+        filter &= ~(0x1 << LLInventoryType::IT_SNAPSHOT);
+        filtered_by_all_types = false;
+    }
 
     if (!getChild<LLUICtrl>("check_settings")->getValue())
     {
@@ -1301,11 +1301,11 @@ void LLFloaterInventoryFinder::draw()
         filtered_by_all_types = false;
     }
 
-	if (!filtered_by_all_types || (mPanelMainInventory->getPanel()->getFilter().getFilterTypes() & LLInventoryFilter::FILTERTYPE_DATE))
-	{
-		// don't include folders in filter, unless I've selected everything or filtering by date
-		filter &= ~(0x1 << LLInventoryType::IT_CATEGORY);
-	}
+    if (!filtered_by_all_types || (mPanelMainInventory->getPanel()->getFilter().getFilterTypes() & LLInventoryFilter::FILTERTYPE_DATE))
+    {
+        // don't include folders in filter, unless I've selected everything or filtering by date
+        filter &= ~(0x1 << LLInventoryType::IT_CATEGORY);
+    }
 
 
     bool is_sf_mode = mPanelMainInventory->isSingleFolderMode();
@@ -1329,28 +1329,28 @@ void LLFloaterInventoryFinder::draw()
         mPanelMainInventory->getPanel()->setFilterTypes(filter);
     }
 
-	if (getCheckSinceLogoff())
-	{
-		mSpinSinceDays->set(0);
-		mSpinSinceHours->set(0);
-	}
-	U32 days = (U32)mSpinSinceDays->get();
-	U32 hours = (U32)mSpinSinceHours->get();
-	if (hours >= 24)
-	{
-		days = hours / 24;
-		hours = (U32)hours % 24;
-		// A UI element that has focus will not display a new value set to it
-		mSpinSinceHours->setFocus(false);
-		mSpinSinceDays->setFocus(false);
-		mSpinSinceDays->set((F32)days);
-		mSpinSinceHours->set((F32)hours);
-		mSpinSinceHours->setFocus(true);
-	}
-	hours += days * 24;
-
-
-	mPanelMainInventory->setFilterTextFromFilter();
+    if (getCheckSinceLogoff())
+    {
+        mSpinSinceDays->set(0);
+        mSpinSinceHours->set(0);
+    }
+    U32 days = (U32)mSpinSinceDays->get();
+    U32 hours = (U32)mSpinSinceHours->get();
+    if (hours >= 24)
+    {
+        days = hours / 24;
+        hours = (U32)hours % 24;
+        // A UI element that has focus will not display a new value set to it
+        mSpinSinceHours->setFocus(false);
+        mSpinSinceDays->setFocus(false);
+        mSpinSinceDays->set((F32)days);
+        mSpinSinceHours->set((F32)hours);
+        mSpinSinceHours->setFocus(true);
+    }
+    hours += days * 24;
+
+
+    mPanelMainInventory->setFilterTextFromFilter();
     if(is_sf_mode && mPanelMainInventory->isGalleryViewMode())
     {
         mPanelMainInventory->mCombinationGalleryPanel->getFilter().setHoursAgo(hours);
@@ -1370,109 +1370,109 @@ void LLFloaterInventoryFinder::draw()
         mPanelMainInventory->getPanel()->setDateSearchDirection(getDateSearchDirection());
     }
 
-	LLPanel::draw();
+    LLPanel::draw();
 }
 
 void LLFloaterInventoryFinder::onCreatorSelfFilterCommit()
 {
-	bool show_creator_self = mCreatorSelf->getValue();
-	bool show_creator_other = mCreatorOthers->getValue();
+    bool show_creator_self = mCreatorSelf->getValue();
+    bool show_creator_other = mCreatorOthers->getValue();
 
-	if(show_creator_self && show_creator_other)
-	{
+    if(show_creator_self && show_creator_other)
+    {
         mPanelMainInventory->getCurrentFilter().setFilterCreator(LLInventoryFilter::FILTERCREATOR_ALL);
-	}
-	else if(show_creator_self)
-	{
+    }
+    else if(show_creator_self)
+    {
         mPanelMainInventory->getCurrentFilter().setFilterCreator(LLInventoryFilter::FILTERCREATOR_SELF);
-	}
-	else if(!show_creator_self || !show_creator_other)
-	{
+    }
+    else if(!show_creator_self || !show_creator_other)
+    {
         mPanelMainInventory->getCurrentFilter().setFilterCreator(LLInventoryFilter::FILTERCREATOR_OTHERS);
-		mCreatorOthers->set(true);
-	}
+        mCreatorOthers->set(true);
+    }
 }
 
 void LLFloaterInventoryFinder::onCreatorOtherFilterCommit()
 {
-	bool show_creator_self = mCreatorSelf->getValue();
-	bool show_creator_other = mCreatorOthers->getValue();
+    bool show_creator_self = mCreatorSelf->getValue();
+    bool show_creator_other = mCreatorOthers->getValue();
 
-	if(show_creator_self && show_creator_other)
-	{
+    if(show_creator_self && show_creator_other)
+    {
         mPanelMainInventory->getCurrentFilter().setFilterCreator(LLInventoryFilter::FILTERCREATOR_ALL);
-	}
-	else if(show_creator_other)
-	{
+    }
+    else if(show_creator_other)
+    {
         mPanelMainInventory->getCurrentFilter().setFilterCreator(LLInventoryFilter::FILTERCREATOR_OTHERS);
-	}
-	else if(!show_creator_other || !show_creator_self)
-	{
+    }
+    else if(!show_creator_other || !show_creator_self)
+    {
         mPanelMainInventory->getCurrentFilter().setFilterCreator(LLInventoryFilter::FILTERCREATOR_SELF);
-		mCreatorSelf->set(true);
-	}
+        mCreatorSelf->set(true);
+    }
 }
 
 bool LLFloaterInventoryFinder::getCheckShowEmpty()
 {
-	return getChild<LLUICtrl>("check_show_empty")->getValue();
+    return getChild<LLUICtrl>("check_show_empty")->getValue();
 }
 
 bool LLFloaterInventoryFinder::getCheckSinceLogoff()
 {
-	return getChild<LLUICtrl>("check_since_logoff")->getValue();
+    return getChild<LLUICtrl>("check_since_logoff")->getValue();
 }
 
 U32 LLFloaterInventoryFinder::getDateSearchDirection()
 {
-	return 	getChild<LLRadioGroup>("date_search_direction")->getSelectedIndex();
+    return  getChild<LLRadioGroup>("date_search_direction")->getSelectedIndex();
 }
 
 void LLFloaterInventoryFinder::onCloseBtn(void* user_data)
 {
-	LLFloaterInventoryFinder* finderp = (LLFloaterInventoryFinder*)user_data;
-	finderp->closeFloater();
+    LLFloaterInventoryFinder* finderp = (LLFloaterInventoryFinder*)user_data;
+    finderp->closeFloater();
 }
 
 // static
 void LLFloaterInventoryFinder::selectAllTypes(void* user_data)
 {
-	LLFloaterInventoryFinder* self = (LLFloaterInventoryFinder*)user_data;
-	if(!self) return;
-
-	self->getChild<LLUICtrl>("check_animation")->setValue(true);
-	self->getChild<LLUICtrl>("check_calling_card")->setValue(true);
-	self->getChild<LLUICtrl>("check_clothing")->setValue(true);
-	self->getChild<LLUICtrl>("check_gesture")->setValue(true);
-	self->getChild<LLUICtrl>("check_landmark")->setValue(true);
-	self->getChild<LLUICtrl>("check_material")->setValue(true);
-	self->getChild<LLUICtrl>("check_notecard")->setValue(true);
-	self->getChild<LLUICtrl>("check_object")->setValue(true);
-	self->getChild<LLUICtrl>("check_script")->setValue(true);
-	self->getChild<LLUICtrl>("check_sound")->setValue(true);
-	self->getChild<LLUICtrl>("check_texture")->setValue(true);
-	self->getChild<LLUICtrl>("check_snapshot")->setValue(true);
+    LLFloaterInventoryFinder* self = (LLFloaterInventoryFinder*)user_data;
+    if(!self) return;
+
+    self->getChild<LLUICtrl>("check_animation")->setValue(true);
+    self->getChild<LLUICtrl>("check_calling_card")->setValue(true);
+    self->getChild<LLUICtrl>("check_clothing")->setValue(true);
+    self->getChild<LLUICtrl>("check_gesture")->setValue(true);
+    self->getChild<LLUICtrl>("check_landmark")->setValue(true);
+    self->getChild<LLUICtrl>("check_material")->setValue(true);
+    self->getChild<LLUICtrl>("check_notecard")->setValue(true);
+    self->getChild<LLUICtrl>("check_object")->setValue(true);
+    self->getChild<LLUICtrl>("check_script")->setValue(true);
+    self->getChild<LLUICtrl>("check_sound")->setValue(true);
+    self->getChild<LLUICtrl>("check_texture")->setValue(true);
+    self->getChild<LLUICtrl>("check_snapshot")->setValue(true);
     self->getChild<LLUICtrl>("check_settings")->setValue(true);
 }
 
 //static
 void LLFloaterInventoryFinder::selectNoTypes(void* user_data)
 {
-	LLFloaterInventoryFinder* self = (LLFloaterInventoryFinder*)user_data;
-	if(!self) return;
-
-	self->getChild<LLUICtrl>("check_animation")->setValue(false);
-	self->getChild<LLUICtrl>("check_calling_card")->setValue(false);
-	self->getChild<LLUICtrl>("check_clothing")->setValue(false);
-	self->getChild<LLUICtrl>("check_gesture")->setValue(false);
-	self->getChild<LLUICtrl>("check_landmark")->setValue(false);
-	self->getChild<LLUICtrl>("check_material")->setValue(false);
-	self->getChild<LLUICtrl>("check_notecard")->setValue(false);
-	self->getChild<LLUICtrl>("check_object")->setValue(false);
-	self->getChild<LLUICtrl>("check_script")->setValue(false);
-	self->getChild<LLUICtrl>("check_sound")->setValue(false);
-	self->getChild<LLUICtrl>("check_texture")->setValue(false);
-	self->getChild<LLUICtrl>("check_snapshot")->setValue(false);
+    LLFloaterInventoryFinder* self = (LLFloaterInventoryFinder*)user_data;
+    if(!self) return;
+
+    self->getChild<LLUICtrl>("check_animation")->setValue(false);
+    self->getChild<LLUICtrl>("check_calling_card")->setValue(false);
+    self->getChild<LLUICtrl>("check_clothing")->setValue(false);
+    self->getChild<LLUICtrl>("check_gesture")->setValue(false);
+    self->getChild<LLUICtrl>("check_landmark")->setValue(false);
+    self->getChild<LLUICtrl>("check_material")->setValue(false);
+    self->getChild<LLUICtrl>("check_notecard")->setValue(false);
+    self->getChild<LLUICtrl>("check_object")->setValue(false);
+    self->getChild<LLUICtrl>("check_script")->setValue(false);
+    self->getChild<LLUICtrl>("check_sound")->setValue(false);
+    self->getChild<LLUICtrl>("check_texture")->setValue(false);
+    self->getChild<LLUICtrl>("check_snapshot")->setValue(false);
     self->getChild<LLUICtrl>("check_settings")->setValue(false);
 }
 
@@ -1481,28 +1481,28 @@ void LLFloaterInventoryFinder::selectNoTypes(void* user_data)
 
 void LLPanelMainInventory::initListCommandsHandlers()
 {
-	childSetAction("add_btn", boost::bind(&LLPanelMainInventory::onAddButtonClick, this));
+    childSetAction("add_btn", boost::bind(&LLPanelMainInventory::onAddButtonClick, this));
     childSetAction("view_mode_btn", boost::bind(&LLPanelMainInventory::onViewModeClick, this));
     childSetAction("up_btn", boost::bind(&LLPanelMainInventory::onUpFolderClicked, this));
     childSetAction("back_btn", boost::bind(&LLPanelMainInventory::onBackFolderClicked, this));
     childSetAction("forward_btn", boost::bind(&LLPanelMainInventory::onForwardFolderClicked, this));
 
-	mCommitCallbackRegistrar.add("Inventory.GearDefault.Custom.Action", boost::bind(&LLPanelMainInventory::onCustomAction, this, _2));
-	mEnableCallbackRegistrar.add("Inventory.GearDefault.Check", boost::bind(&LLPanelMainInventory::isActionChecked, this, _2));
-	mEnableCallbackRegistrar.add("Inventory.GearDefault.Enable", boost::bind(&LLPanelMainInventory::isActionEnabled, this, _2));
+    mCommitCallbackRegistrar.add("Inventory.GearDefault.Custom.Action", boost::bind(&LLPanelMainInventory::onCustomAction, this, _2));
+    mEnableCallbackRegistrar.add("Inventory.GearDefault.Check", boost::bind(&LLPanelMainInventory::isActionChecked, this, _2));
+    mEnableCallbackRegistrar.add("Inventory.GearDefault.Enable", boost::bind(&LLPanelMainInventory::isActionEnabled, this, _2));
     mEnableCallbackRegistrar.add("Inventory.GearDefault.Visible", boost::bind(&LLPanelMainInventory::isActionVisible, this, _2));
-	mMenuGearDefault = LLUICtrlFactory::getInstance()->createFromFile<LLToggleableMenu>("menu_inventory_gear_default.xml", gMenuHolder, LLViewerMenuHolderGL::child_registry_t::instance());
-	mGearMenuButton->setMenu(mMenuGearDefault, LLMenuButton::MP_BOTTOM_LEFT, true);
+    mMenuGearDefault = LLUICtrlFactory::getInstance()->createFromFile<LLToggleableMenu>("menu_inventory_gear_default.xml", gMenuHolder, LLViewerMenuHolderGL::child_registry_t::instance());
+    mGearMenuButton->setMenu(mMenuGearDefault, LLMenuButton::MP_BOTTOM_LEFT, true);
     mMenuViewDefault = LLUICtrlFactory::getInstance()->createFromFile<LLToggleableMenu>("menu_inventory_view_default.xml", gMenuHolder, LLViewerMenuHolderGL::child_registry_t::instance());
     mViewMenuButton->setMenu(mMenuViewDefault, LLMenuButton::MP_BOTTOM_LEFT, true);
-	LLMenuGL* menu = LLUICtrlFactory::getInstance()->createFromFile<LLMenuGL>("menu_inventory_add.xml", gMenuHolder, LLViewerMenuHolderGL::child_registry_t::instance());
-	mMenuAddHandle = menu->getHandle();
+    LLMenuGL* menu = LLUICtrlFactory::getInstance()->createFromFile<LLMenuGL>("menu_inventory_add.xml", gMenuHolder, LLViewerMenuHolderGL::child_registry_t::instance());
+    mMenuAddHandle = menu->getHandle();
 
-	mMenuVisibility = LLUICtrlFactory::getInstance()->createFromFile<LLToggleableMenu>("menu_inventory_search_visibility.xml", gMenuHolder, LLViewerMenuHolderGL::child_registry_t::instance());
+    mMenuVisibility = LLUICtrlFactory::getInstance()->createFromFile<LLToggleableMenu>("menu_inventory_search_visibility.xml", gMenuHolder, LLViewerMenuHolderGL::child_registry_t::instance());
     mVisibilityMenuButton->setMenu(mMenuVisibility, LLMenuButton::MP_BOTTOM_LEFT, true);
 
-	// Update the trash button when selected item(s) get worn or taken off.
-	LLOutfitObserver::instance().addCOFChangedCallback(boost::bind(&LLPanelMainInventory::updateListCommands, this));
+    // Update the trash button when selected item(s) get worn or taken off.
+    LLOutfitObserver::instance().addCOFChangedCallback(boost::bind(&LLPanelMainInventory::updateListCommands, this));
 }
 
 void LLPanelMainInventory::updateListCommands()
@@ -1514,15 +1514,15 @@ void LLPanelMainInventory::onAddButtonClick()
 // Gray out the "New Folder" option when the Recent tab is active as new folders will not be displayed
 // unless "Always show folders" is checked in the filter options.
 
-	LLMenuGL* menu = (LLMenuGL*)mMenuAddHandle.get();
-	if (menu)
-	{
+    LLMenuGL* menu = (LLMenuGL*)mMenuAddHandle.get();
+    if (menu)
+    {
         disableAddIfNeeded();
 
-		setUploadCostIfNeeded();
+        setUploadCostIfNeeded();
 
-		showActionMenu(menu,"add_btn");
-	}
+        showActionMenu(menu,"add_btn");
+    }
 }
 
 void LLPanelMainInventory::setActivePanel()
@@ -1736,22 +1736,22 @@ LLUUID LLPanelMainInventory::getSingleFolderViewRoot()
 
 void LLPanelMainInventory::showActionMenu(LLMenuGL* menu, std::string spawning_view_name)
 {
-	if (menu)
-	{
-		menu->buildDrawLabels();
-		menu->updateParent(LLMenuGL::sMenuContainer);
-		LLView* spawning_view = getChild<LLView> (spawning_view_name);
-		S32 menu_x, menu_y;
-		//show menu in co-ordinates of panel
-		spawning_view->localPointToOtherView(0, 0, &menu_x, &menu_y, this);
-		LLMenuGL::showPopup(this, menu, menu_x, menu_y);
-	}
+    if (menu)
+    {
+        menu->buildDrawLabels();
+        menu->updateParent(LLMenuGL::sMenuContainer);
+        LLView* spawning_view = getChild<LLView> (spawning_view_name);
+        S32 menu_x, menu_y;
+        //show menu in co-ordinates of panel
+        spawning_view->localPointToOtherView(0, 0, &menu_x, &menu_y, this);
+        LLMenuGL::showPopup(this, menu, menu_x, menu_y);
+    }
 }
 
 void LLPanelMainInventory::onClipboardAction(const LLSD& userdata)
 {
-	std::string command_name = userdata.asString();
-	getActivePanel()->doToSelected(command_name);
+    std::string command_name = userdata.asString();
+    getActivePanel()->doToSelected(command_name);
 }
 
 void LLPanelMainInventory::saveTexture(const LLSD& userdata)
@@ -1772,89 +1772,89 @@ void LLPanelMainInventory::saveTexture(const LLSD& userdata)
         item_id = static_cast<LLFolderViewModelItemInventory*>(current_item->getViewModelItem())->getUUID();
     }
 
-	LLPreviewTexture* preview_texture = LLFloaterReg::showTypedInstance<LLPreviewTexture>("preview_texture", LLSD(item_id), TAKE_FOCUS_YES);
-	if (preview_texture)
-	{
-		preview_texture->openToSave();
-	}
+    LLPreviewTexture* preview_texture = LLFloaterReg::showTypedInstance<LLPreviewTexture>("preview_texture", LLSD(item_id), TAKE_FOCUS_YES);
+    if (preview_texture)
+    {
+        preview_texture->openToSave();
+    }
 }
 
 void LLPanelMainInventory::onCustomAction(const LLSD& userdata)
 {
-	if (!isActionEnabled(userdata))
-		return;
-
-	const std::string command_name = userdata.asString();
-
-	if (command_name == "new_window")
-	{
-		newWindow();
-	}
-	if (command_name == "sort_by_name")
-	{
-		const LLSD arg = "name";
-		setSortBy(arg);
-	}
-	if (command_name == "sort_by_recent")
-	{
-		const LLSD arg = "date";
-		setSortBy(arg);
-	}
-	if (command_name == "sort_folders_by_name")
-	{
-		const LLSD arg = "foldersalwaysbyname";
-		setSortBy(arg);
-	}
-	if (command_name == "sort_system_folders_to_top")
-	{
-		const LLSD arg = "systemfolderstotop";
-		setSortBy(arg);
-	}
-	if (command_name == "show_filters")
-	{
-		toggleFindOptions();
-	}
-	if (command_name == "reset_filters")
-	{
-		resetFilters();
-	}
-	if (command_name == "close_folders")
-	{
-		closeAllFolders();
-	}
-	if (command_name == "empty_trash")
-	{
-		const std::string notification = "ConfirmEmptyTrash";
-		gInventory.emptyFolderType(notification, LLFolderType::FT_TRASH);
-	}
-	if (command_name == "empty_lostnfound")
-	{
-		const std::string notification = "ConfirmEmptyLostAndFound";
-		gInventory.emptyFolderType(notification, LLFolderType::FT_LOST_AND_FOUND);
-	}
-	if (command_name == "save_texture")
-	{
-		saveTexture(userdata);
-	}
-	// This doesn't currently work, since the viewer can't change an assetID an item.
-	if (command_name == "regenerate_link")
-	{
-		LLInventoryPanel *active_panel = getActivePanel();
-		LLFolderViewItem* current_item = active_panel->getRootFolder()->getCurSelectedItem();
-		if (!current_item)
-		{
-			return;
-		}
-		const LLUUID item_id = static_cast<LLFolderViewModelItemInventory*>(current_item->getViewModelItem())->getUUID();
-		LLViewerInventoryItem *item = gInventory.getItem(item_id);
-		if (item)
-		{
-			item->regenerateLink();
-		}
-		active_panel->setSelection(item_id, TAKE_FOCUS_NO);
-	}
-	if (command_name == "find_original")
-	{
+    if (!isActionEnabled(userdata))
+        return;
+
+    const std::string command_name = userdata.asString();
+
+    if (command_name == "new_window")
+    {
+        newWindow();
+    }
+    if (command_name == "sort_by_name")
+    {
+        const LLSD arg = "name";
+        setSortBy(arg);
+    }
+    if (command_name == "sort_by_recent")
+    {
+        const LLSD arg = "date";
+        setSortBy(arg);
+    }
+    if (command_name == "sort_folders_by_name")
+    {
+        const LLSD arg = "foldersalwaysbyname";
+        setSortBy(arg);
+    }
+    if (command_name == "sort_system_folders_to_top")
+    {
+        const LLSD arg = "systemfolderstotop";
+        setSortBy(arg);
+    }
+    if (command_name == "show_filters")
+    {
+        toggleFindOptions();
+    }
+    if (command_name == "reset_filters")
+    {
+        resetFilters();
+    }
+    if (command_name == "close_folders")
+    {
+        closeAllFolders();
+    }
+    if (command_name == "empty_trash")
+    {
+        const std::string notification = "ConfirmEmptyTrash";
+        gInventory.emptyFolderType(notification, LLFolderType::FT_TRASH);
+    }
+    if (command_name == "empty_lostnfound")
+    {
+        const std::string notification = "ConfirmEmptyLostAndFound";
+        gInventory.emptyFolderType(notification, LLFolderType::FT_LOST_AND_FOUND);
+    }
+    if (command_name == "save_texture")
+    {
+        saveTexture(userdata);
+    }
+    // This doesn't currently work, since the viewer can't change an assetID an item.
+    if (command_name == "regenerate_link")
+    {
+        LLInventoryPanel *active_panel = getActivePanel();
+        LLFolderViewItem* current_item = active_panel->getRootFolder()->getCurSelectedItem();
+        if (!current_item)
+        {
+            return;
+        }
+        const LLUUID item_id = static_cast<LLFolderViewModelItemInventory*>(current_item->getViewModelItem())->getUUID();
+        LLViewerInventoryItem *item = gInventory.getItem(item_id);
+        if (item)
+        {
+            item->regenerateLink();
+        }
+        active_panel->setSelection(item_id, TAKE_FOCUS_NO);
+    }
+    if (command_name == "find_original")
+    {
         if(mSingleFolderMode && isGalleryViewMode())
         {
             LLInventoryObject *obj = gInventory.getObject(mCombinationGalleryPanel->getFirstSelectedItemID());
@@ -1865,17 +1865,17 @@ void LLPanelMainInventory::onCustomAction(const LLSD& userdata)
         }
         else
         {
-		LLFolderViewItem* current_item = getActivePanel()->getRootFolder()->getCurSelectedItem();
-		if (!current_item)
-		{
-			return;
-		}
-		static_cast<LLFolderViewModelItemInventory*>(current_item->getViewModelItem())->performAction(getActivePanel()->getModel(), "goto");
+        LLFolderViewItem* current_item = getActivePanel()->getRootFolder()->getCurSelectedItem();
+        if (!current_item)
+        {
+            return;
+        }
+        static_cast<LLFolderViewModelItemInventory*>(current_item->getViewModelItem())->performAction(getActivePanel()->getModel(), "goto");
         }
-	}
+    }
 
-	if (command_name == "find_links")
-	{
+    if (command_name == "find_links")
+    {
         if(mSingleFolderMode && isGalleryViewMode())
         {
             LLFloaterSidePanelContainer* inventory_container = newWindow();
@@ -1907,10 +1907,10 @@ void LLPanelMainInventory::onCustomAction(const LLSD& userdata)
             const std::string &item_name = current_item->getViewModelItem()->getName();
             findLinks(item_id, item_name);
         }
-	}
+    }
 
-	if (command_name == "replace_links")
-	{
+    if (command_name == "replace_links")
+    {
         LLSD params;
         if(mSingleFolderMode && isGalleryViewMode())
         {
@@ -1918,23 +1918,23 @@ void LLPanelMainInventory::onCustomAction(const LLSD& userdata)
         }
         else
         {
-		LLFolderViewItem* current_item = getActivePanel()->getRootFolder()->getCurSelectedItem();
-		if (current_item)
-		{
-			LLInvFVBridge* bridge = (LLInvFVBridge*)current_item->getViewModelItem();
+        LLFolderViewItem* current_item = getActivePanel()->getRootFolder()->getCurSelectedItem();
+        if (current_item)
+        {
+            LLInvFVBridge* bridge = (LLInvFVBridge*)current_item->getViewModelItem();
 
-			if (bridge)
-			{
-				LLInventoryObject* obj = bridge->getInventoryObject();
-				if (obj && obj->getType() != LLAssetType::AT_CATEGORY && obj->getActualType() != LLAssetType::AT_LINK_FOLDER)
-				{
-					params = LLSD(obj->getUUID());
-				}
-			}
-		}
+            if (bridge)
+            {
+                LLInventoryObject* obj = bridge->getInventoryObject();
+                if (obj && obj->getType() != LLAssetType::AT_CATEGORY && obj->getActualType() != LLAssetType::AT_LINK_FOLDER)
+                {
+                    params = LLSD(obj->getUUID());
+                }
+            }
         }
-		LLFloaterReg::showInstance("linkreplace", params);
-	}
+        }
+        LLFloaterReg::showInstance("linkreplace", params);
+    }
 
     if (command_name == "close_inv_windows")
     {
@@ -1955,20 +1955,20 @@ void LLPanelMainInventory::onCustomAction(const LLSD& userdata)
         getCurrentFilter().toggleSearchVisibilityOutfits();
     }
 
-	if (command_name == "toggle_search_trash")
-	{
+    if (command_name == "toggle_search_trash")
+    {
         getCurrentFilter().toggleSearchVisibilityTrash();
-	}
+    }
 
-	if (command_name == "toggle_search_library")
-	{
+    if (command_name == "toggle_search_library")
+    {
         getCurrentFilter().toggleSearchVisibilityLibrary();
-	}
+    }
 
-	if (command_name == "include_links")
-	{
+    if (command_name == "include_links")
+    {
         getCurrentFilter().toggleSearchVisibilityLinks();
-	}
+    }
 
     if (command_name == "share")
     {
@@ -2002,15 +2002,15 @@ void LLPanelMainInventory::onCustomAction(const LLSD& userdata)
 
 void LLPanelMainInventory::onVisibilityChange( bool new_visibility )
 {
-	if(!new_visibility)
-	{
-		LLMenuGL* menu = (LLMenuGL*)mMenuAddHandle.get();
-		if (menu)
-		{
-			menu->setVisible(false);
-		}
-		getActivePanel()->getRootFolder()->finishRenamingItem();
-	}
+    if(!new_visibility)
+    {
+        LLMenuGL* menu = (LLMenuGL*)mMenuAddHandle.get();
+        if (menu)
+        {
+            menu->setVisible(false);
+        }
+        getActivePanel()->getRootFolder()->finishRenamingItem();
+    }
 }
 
 bool LLPanelMainInventory::isSaveTextureEnabled(const LLSD& userdata)
@@ -2028,124 +2028,124 @@ bool LLPanelMainInventory::isSaveTextureEnabled(const LLSD& userdata)
             inv_item = dynamic_cast<LLViewerInventoryItem*>(static_cast<LLFolderViewModelItemInventory*>(current_item->getViewModelItem())->getInventoryObject());
         }
     }
-		if(inv_item)
-		{
-			bool can_save = inv_item->checkPermissionsSet(PERM_ITEM_UNRESTRICTED);
+        if(inv_item)
+        {
+            bool can_save = inv_item->checkPermissionsSet(PERM_ITEM_UNRESTRICTED);
             LLInventoryType::EType curr_type = inv_item->getInventoryType();
-			return can_save && (curr_type == LLInventoryType::IT_TEXTURE || curr_type == LLInventoryType::IT_SNAPSHOT);
-		}
+            return can_save && (curr_type == LLInventoryType::IT_TEXTURE || curr_type == LLInventoryType::IT_SNAPSHOT);
+        }
 
-	return false;
+    return false;
 }
 
 bool LLPanelMainInventory::isActionEnabled(const LLSD& userdata)
 {
-	const std::string command_name = userdata.asString();
-	if (command_name == "not_empty")
-	{
-		bool status = false;
-		LLFolderViewItem* current_item = getActivePanel()->getRootFolder()->getCurSelectedItem();
-		if (current_item)
-		{
-			const LLUUID& item_id = static_cast<LLFolderViewModelItemInventory*>(current_item->getViewModelItem())->getUUID();
-			LLInventoryModel::cat_array_t* cat_array;
-			LLInventoryModel::item_array_t* item_array;
-			gInventory.getDirectDescendentsOf(item_id, cat_array, item_array);
-			status = (0 == cat_array->size() && 0 == item_array->size());
-		}
-		return status;
-	}
-	if (command_name == "delete")
-	{
-		return getActivePanel()->isSelectionRemovable();
-	}
-	if (command_name == "save_texture")
-	{
-		return isSaveTextureEnabled(userdata);
-	}
-	if (command_name == "find_original")
-	{
+    const std::string command_name = userdata.asString();
+    if (command_name == "not_empty")
+    {
+        bool status = false;
+        LLFolderViewItem* current_item = getActivePanel()->getRootFolder()->getCurSelectedItem();
+        if (current_item)
+        {
+            const LLUUID& item_id = static_cast<LLFolderViewModelItemInventory*>(current_item->getViewModelItem())->getUUID();
+            LLInventoryModel::cat_array_t* cat_array;
+            LLInventoryModel::item_array_t* item_array;
+            gInventory.getDirectDescendentsOf(item_id, cat_array, item_array);
+            status = (0 == cat_array->size() && 0 == item_array->size());
+        }
+        return status;
+    }
+    if (command_name == "delete")
+    {
+        return getActivePanel()->isSelectionRemovable();
+    }
+    if (command_name == "save_texture")
+    {
+        return isSaveTextureEnabled(userdata);
+    }
+    if (command_name == "find_original")
+    {
         LLUUID item_id;
         if(mSingleFolderMode && isGalleryViewMode())
         {
             item_id = mCombinationGalleryPanel->getFirstSelectedItemID();
         }
         else{
-		LLFolderViewItem* current_item = getActivePanel()->getRootFolder()->getCurSelectedItem();
-		if (!current_item) return false;
+        LLFolderViewItem* current_item = getActivePanel()->getRootFolder()->getCurSelectedItem();
+        if (!current_item) return false;
         item_id = static_cast<LLFolderViewModelItemInventory*>(current_item->getViewModelItem())->getUUID();
         }
-		const LLViewerInventoryItem *item = gInventory.getItem(item_id);
-		if (item && item->getIsLinkType() && !item->getIsBrokenLink())
-		{
-			return true;
-		}
-		return false;
-	}
+        const LLViewerInventoryItem *item = gInventory.getItem(item_id);
+        if (item && item->getIsLinkType() && !item->getIsBrokenLink())
+        {
+            return true;
+        }
+        return false;
+    }
 
-	if (command_name == "find_links")
-	{
+    if (command_name == "find_links")
+    {
         LLUUID item_id;
         if(mSingleFolderMode && isGalleryViewMode())
         {
             item_id = mCombinationGalleryPanel->getFirstSelectedItemID();
         }
         else{
-		LLFolderView* root = getActivePanel()->getRootFolder();
-		std::set<LLFolderViewItem*> selection_set = root->getSelectionList();
-		if (selection_set.size() != 1) return false;
-		LLFolderViewItem* current_item = root->getCurSelectedItem();
-		if (!current_item) return false;
-		item_id = static_cast<LLFolderViewModelItemInventory*>(current_item->getViewModelItem())->getUUID();
-        }
-		const LLInventoryObject *obj = gInventory.getObject(item_id);
-		if (obj && !obj->getIsLinkType() && LLAssetType::lookupCanLink(obj->getType()))
-		{
-			return true;
-		}
-		return false;
-	}
-	// This doesn't currently work, since the viewer can't change an assetID an item.
-	if (command_name == "regenerate_link")
-	{
-		LLFolderViewItem* current_item = getActivePanel()->getRootFolder()->getCurSelectedItem();
-		if (!current_item) return false;
-		const LLUUID& item_id = static_cast<LLFolderViewModelItemInventory*>(current_item->getViewModelItem())->getUUID();
-		const LLViewerInventoryItem *item = gInventory.getItem(item_id);
-		if (item && item->getIsBrokenLink())
-		{
-			return true;
-		}
-		return false;
-	}
-
-	if (command_name == "share")
-	{
+        LLFolderView* root = getActivePanel()->getRootFolder();
+        std::set<LLFolderViewItem*> selection_set = root->getSelectionList();
+        if (selection_set.size() != 1) return false;
+        LLFolderViewItem* current_item = root->getCurSelectedItem();
+        if (!current_item) return false;
+        item_id = static_cast<LLFolderViewModelItemInventory*>(current_item->getViewModelItem())->getUUID();
+        }
+        const LLInventoryObject *obj = gInventory.getObject(item_id);
+        if (obj && !obj->getIsLinkType() && LLAssetType::lookupCanLink(obj->getType()))
+        {
+            return true;
+        }
+        return false;
+    }
+    // This doesn't currently work, since the viewer can't change an assetID an item.
+    if (command_name == "regenerate_link")
+    {
+        LLFolderViewItem* current_item = getActivePanel()->getRootFolder()->getCurSelectedItem();
+        if (!current_item) return false;
+        const LLUUID& item_id = static_cast<LLFolderViewModelItemInventory*>(current_item->getViewModelItem())->getUUID();
+        const LLViewerInventoryItem *item = gInventory.getItem(item_id);
+        if (item && item->getIsBrokenLink())
+        {
+            return true;
+        }
+        return false;
+    }
+
+    if (command_name == "share")
+    {
         if(mSingleFolderMode && isGalleryViewMode())
         {
             return can_share_item(mCombinationGalleryPanel->getFirstSelectedItemID());
         }
         else{
-		LLFolderViewItem* current_item = getActivePanel()->getRootFolder()->getCurSelectedItem();
-		if (!current_item) return false;
-		LLSidepanelInventory* parent = LLFloaterSidePanelContainer::getPanel<LLSidepanelInventory>("inventory");
-		return parent ? parent->canShare() : false;
-        }
-	}
-	if (command_name == "empty_trash")
-	{
-		const LLUUID &trash_id = gInventory.findCategoryUUIDForType(LLFolderType::FT_TRASH);
-		LLInventoryModel::EHasChildren children = gInventory.categoryHasChildren(trash_id);
-		return children != LLInventoryModel::CHILDREN_NO && gInventory.isCategoryComplete(trash_id);
-	}
-	if (command_name == "empty_lostnfound")
-	{
-		const LLUUID &trash_id = gInventory.findCategoryUUIDForType(LLFolderType::FT_LOST_AND_FOUND);
-		LLInventoryModel::EHasChildren children = gInventory.categoryHasChildren(trash_id);
-		return children != LLInventoryModel::CHILDREN_NO && gInventory.isCategoryComplete(trash_id);
-	}
-
-	return true;
+        LLFolderViewItem* current_item = getActivePanel()->getRootFolder()->getCurSelectedItem();
+        if (!current_item) return false;
+        LLSidepanelInventory* parent = LLFloaterSidePanelContainer::getPanel<LLSidepanelInventory>("inventory");
+        return parent ? parent->canShare() : false;
+        }
+    }
+    if (command_name == "empty_trash")
+    {
+        const LLUUID &trash_id = gInventory.findCategoryUUIDForType(LLFolderType::FT_TRASH);
+        LLInventoryModel::EHasChildren children = gInventory.categoryHasChildren(trash_id);
+        return children != LLInventoryModel::CHILDREN_NO && gInventory.isCategoryComplete(trash_id);
+    }
+    if (command_name == "empty_lostnfound")
+    {
+        const LLUUID &trash_id = gInventory.findCategoryUUIDForType(LLFolderType::FT_LOST_AND_FOUND);
+        LLInventoryModel::EHasChildren children = gInventory.categoryHasChildren(trash_id);
+        return children != LLInventoryModel::CHILDREN_NO && gInventory.isCategoryComplete(trash_id);
+    }
+
+    return true;
 }
 
 bool LLPanelMainInventory::isActionVisible(const LLSD& userdata)
@@ -2165,47 +2165,47 @@ bool LLPanelMainInventory::isActionVisible(const LLSD& userdata)
 
 bool LLPanelMainInventory::isActionChecked(const LLSD& userdata)
 {
-	U32 sort_order_mask = (mSingleFolderMode && isGalleryViewMode()) ? mCombinationGalleryPanel->getSortOrder() :  getActivePanel()->getSortOrder();
-	const std::string command_name = userdata.asString();
-	if (command_name == "sort_by_name")
-	{
-		return ~sort_order_mask & LLInventoryFilter::SO_DATE;
-	}
+    U32 sort_order_mask = (mSingleFolderMode && isGalleryViewMode()) ? mCombinationGalleryPanel->getSortOrder() :  getActivePanel()->getSortOrder();
+    const std::string command_name = userdata.asString();
+    if (command_name == "sort_by_name")
+    {
+        return ~sort_order_mask & LLInventoryFilter::SO_DATE;
+    }
 
-	if (command_name == "sort_by_recent")
-	{
-		return sort_order_mask & LLInventoryFilter::SO_DATE;
-	}
+    if (command_name == "sort_by_recent")
+    {
+        return sort_order_mask & LLInventoryFilter::SO_DATE;
+    }
 
-	if (command_name == "sort_folders_by_name")
-	{
-		return sort_order_mask & LLInventoryFilter::SO_FOLDERS_BY_NAME;
-	}
+    if (command_name == "sort_folders_by_name")
+    {
+        return sort_order_mask & LLInventoryFilter::SO_FOLDERS_BY_NAME;
+    }
 
-	if (command_name == "sort_system_folders_to_top")
-	{
-		return sort_order_mask & LLInventoryFilter::SO_SYSTEM_FOLDERS_TO_TOP;
-	}
+    if (command_name == "sort_system_folders_to_top")
+    {
+        return sort_order_mask & LLInventoryFilter::SO_SYSTEM_FOLDERS_TO_TOP;
+    }
 
     if (command_name == "toggle_search_outfits")
     {
         return (getCurrentFilter().getSearchVisibilityTypes() & LLInventoryFilter::VISIBILITY_OUTFITS) != 0;
     }
 
-	if (command_name == "toggle_search_trash")
-	{
-		return (getCurrentFilter().getSearchVisibilityTypes() & LLInventoryFilter::VISIBILITY_TRASH) != 0;
-	}
+    if (command_name == "toggle_search_trash")
+    {
+        return (getCurrentFilter().getSearchVisibilityTypes() & LLInventoryFilter::VISIBILITY_TRASH) != 0;
+    }
 
-	if (command_name == "toggle_search_library")
-	{
-		return (getCurrentFilter().getSearchVisibilityTypes() & LLInventoryFilter::VISIBILITY_LIBRARY) != 0;
-	}
+    if (command_name == "toggle_search_library")
+    {
+        return (getCurrentFilter().getSearchVisibilityTypes() & LLInventoryFilter::VISIBILITY_LIBRARY) != 0;
+    }
 
-	if (command_name == "include_links")
-	{
+    if (command_name == "include_links")
+    {
         return (getCurrentFilter().getSearchVisibilityTypes() & LLInventoryFilter::VISIBILITY_LINKS) != 0;
-	}	
+    }
 
     if (command_name == "list_view")
     {
@@ -2220,20 +2220,20 @@ bool LLPanelMainInventory::isActionChecked(const LLSD& userdata)
         return isCombinationViewMode();
     }
 
-	return false;
+    return false;
 }
 
 void LLPanelMainInventory::setUploadCostIfNeeded()
 {
-	LLMenuGL* menu = (LLMenuGL*)mMenuAddHandle.get();
-	if(mNeedUploadCost && menu)
-	{
-		const std::string sound_upload_cost_str = std::to_string(LLAgentBenefitsMgr::current().getSoundUploadCost());
-		const std::string animation_upload_cost_str = std::to_string(LLAgentBenefitsMgr::current().getAnimationUploadCost());
+    LLMenuGL* menu = (LLMenuGL*)mMenuAddHandle.get();
+    if(mNeedUploadCost && menu)
+    {
+        const std::string sound_upload_cost_str = std::to_string(LLAgentBenefitsMgr::current().getSoundUploadCost());
+        const std::string animation_upload_cost_str = std::to_string(LLAgentBenefitsMgr::current().getAnimationUploadCost());
 
-		menu->getChild<LLView>("Upload Sound")->setLabelArg("[COST]", sound_upload_cost_str);
-		menu->getChild<LLView>("Upload Animation")->setLabelArg("[COST]", animation_upload_cost_str);
-	}
+        menu->getChild<LLView>("Upload Sound")->setLabelArg("[COST]", sound_upload_cost_str);
+        menu->getChild<LLView>("Upload Animation")->setLabelArg("[COST]", animation_upload_cost_str);
+    }
 }
 
 bool is_add_allowed(LLUUID folder_id)
@@ -2413,7 +2413,7 @@ void LLPanelMainInventory::updateCombinationVisibility()
         {
             mCombinationGalleryPanel->handleModifiedFilter();
         }
-        
+
         getActivePanel()->getRootFolder();
 
         if (mReshapeInvLayout
@@ -2537,7 +2537,7 @@ void LLPanelMainInventory::setViewMode(EViewModeType mode)
                 sort_order = mCombinationInventoryPanel->getSortOrder();
                 break;
         }
-            
+
         LLUUID cur_root = getCurrentSFVRoot();
         mViewMode = mode;