Initial version of Visual Outfit Browser

1 files changed, 788 insertions, 446 deletions

diff --git a/indra/newview/lloutfitslist.cpp b/indra/newview/lloutfitslist.cpp
index 883221382c..736da5d411 100755
--- a/indra/newview/lloutfitslist.cpp
+++ b/indra/newview/lloutfitslist.cpp
@@ -38,7 +38,7 @@
 #include "llfloatersidepanelcontainer.h"
 #include "llinventoryfunctions.h"
 #include "llinventorymodel.h"
-#include "lllistcontextmenu.h"
+//#include "lllistcontextmenu.h"
 #include "llmenubutton.h"
 #include "llnotificationsutil.h"
 #include "lloutfitobserver.h"
@@ -98,339 +98,204 @@ const outfit_accordion_tab_params& get_accordion_tab_params()
 }
 
 
-//////////////////////////////////////////////////////////////////////////
+static LLPanelInjector<LLOutfitsList> t_outfits_list("outfits_list");
 
-class LLOutfitListGearMenu
+LLOutfitsList::LLOutfitsList()
+    :   LLOutfitListBase()
+    ,   mAccordion(NULL)
+	,	mListCommands(NULL)
+	,	mItemSelected(false)
 {
-public:
-	LLOutfitListGearMenu(LLOutfitsList* olist)
-	:	mOutfitList(olist),
-		mMenu(NULL)
-	{
-		llassert_always(mOutfitList);
+//	mCategoriesObserver = new LLInventoryCategoriesObserver();
 
-		LLUICtrl::CommitCallbackRegistry::ScopedRegistrar registrar;
-		LLUICtrl::EnableCallbackRegistry::ScopedRegistrar enable_registrar;
-
-		registrar.add("Gear.Wear", boost::bind(&LLOutfitListGearMenu::onWear, this));
-		registrar.add("Gear.TakeOff", boost::bind(&LLOutfitListGearMenu::onTakeOff, this));
-		registrar.add("Gear.Rename", boost::bind(&LLOutfitListGearMenu::onRename, this));
-		registrar.add("Gear.Delete", boost::bind(&LLOutfitsList::removeSelected, mOutfitList));
-		registrar.add("Gear.Create", boost::bind(&LLOutfitListGearMenu::onCreate, this, _2));
-		registrar.add("Gear.Collapse", boost::bind(&LLOutfitsList::collapse_all_folders, mOutfitList));
-		registrar.add("Gear.Expand", boost::bind(&LLOutfitsList::expand_all_folders, mOutfitList));
-
-		registrar.add("Gear.WearAdd", boost::bind(&LLOutfitListGearMenu::onAdd, this));
-
-		enable_registrar.add("Gear.OnEnable", boost::bind(&LLOutfitListGearMenu::onEnable, this, _2));
-		enable_registrar.add("Gear.OnVisible", boost::bind(&LLOutfitListGearMenu::onVisible, this, _2));
-
-		mMenu = LLUICtrlFactory::getInstance()->createFromFile<LLToggleableMenu>(
-			"menu_outfit_gear.xml", gMenuHolder, LLViewerMenuHolderGL::child_registry_t::instance());
-		llassert(mMenu);
-	}
-
-	void updateItemsVisibility()
-	{
-		if (!mMenu) return;
+//	mGearMenu = new LLOutfitListGearMenu(this);
+}
 
-		bool have_selection = getSelectedOutfitID().notNull();
-		mMenu->setItemVisible("sepatator1", have_selection);
-		mMenu->setItemVisible("sepatator2", have_selection);
-		mMenu->arrangeAndClear(); // update menu height
-	}
+LLOutfitsList::~LLOutfitsList()
+{
+//	delete mGearMenu;
+}
 
-	LLToggleableMenu* getMenu() { return mMenu; }
+BOOL LLOutfitsList::postBuild()
+{
+	mAccordion = getChild<LLAccordionCtrl>("outfits_accordion");
+	mAccordion->setComparator(&OUTFIT_TAB_NAME_COMPARATOR);
 
-private:
-	const LLUUID& getSelectedOutfitID()
-	{
-		return mOutfitList->getSelectedOutfitUUID();
-	}
+	//LLMenuButton* menu_gear_btn = getChild<LLMenuButton>("options_gear_btn");
 
-	LLViewerInventoryCategory* getSelectedOutfit()
-	{
-		const LLUUID& selected_outfit_id = getSelectedOutfitID();
-		if (selected_outfit_id.isNull())
-		{
-			return NULL;
-		}
+	//menu_gear_btn->setMouseDownCallback(boost::bind(&LLOutfitListGearMenu::updateItemsVisibility, mGearMenu));
+	//menu_gear_btn->setMenu(mGearMenu->getMenu());
 
-		LLViewerInventoryCategory* cat = gInventory.getCategory(selected_outfit_id);
-		return cat;
-	}
+    return LLOutfitListBase::postBuild();
+}
 
-	void onWear()
-	{
-		LLViewerInventoryCategory* selected_outfit = getSelectedOutfit();
-		if (selected_outfit)
-		{
-			LLAppearanceMgr::instance().wearInventoryCategory(
-				selected_outfit, /*copy=*/ FALSE, /*append=*/ FALSE);
-		}
-	}
+//virtual
+void LLOutfitsList::onOpen(const LLSD& info)
+{
+    if (!mIsInitialized)
+    {
+        const LLUUID cof = gInventory.findCategoryUUIDForType(LLFolderType::FT_CURRENT_OUTFIT);
+        // Start observing changes in Current Outfit category.
+        mCategoriesObserver->addCategory(cof, boost::bind(&LLOutfitsList::onCOFChanged, this));
+    }
 
-	void onAdd()
-	{
-		const LLUUID& selected_id = getSelectedOutfitID();
+    LLOutfitListBase::onOpen(info);
 
-		if (selected_id.notNull())
-		{
-			LLAppearanceMgr::getInstance()->addCategoryToCurrentOutfit(selected_id);
-		}
-	}
+ //   if (!mIsInitialized)
+	//{
+	//	// *TODO: I'm not sure is this check necessary but it never match while developing.
+	//	if (!gInventory.isInventoryUsable())
+	//		return;
 
-	void onTakeOff()
-	{
-		// Take off selected outfit.
-			const LLUUID& selected_outfit_id = getSelectedOutfitID();
-			if (selected_outfit_id.notNull())
-			{
-				LLAppearanceMgr::instance().takeOffOutfit(selected_outfit_id);
-			}
-		}
+	//	const LLUUID outfits = gInventory.findCategoryUUIDForType(LLFolderType::FT_MY_OUTFITS);
 
-	void onRename()
-	{
-		const LLUUID& selected_outfit_id = getSelectedOutfitID();
-		if (selected_outfit_id.notNull())
-		{
-			LLAppearanceMgr::instance().renameOutfit(selected_outfit_id);
-		}
-	}
+	//	// *TODO: I'm not sure is this check necessary but it never match while developing.
+	//	LLViewerInventoryCategory* category = gInventory.getCategory(outfits);
+	//	if (!category)
+	//		return;
 
-	void onCreate(const LLSD& data)
-	{
-		LLWearableType::EType type = LLWearableType::typeNameToType(data.asString());
-		if (type == LLWearableType::WT_NONE)
-		{
-			LL_WARNS() << "Invalid wearable type" << LL_ENDL;
-			return;
-		}
+	//	gInventory.addObserver(mCategoriesObserver);
 
-		LLAgentWearables::createWearable(type, true);
-	}
+	//	// Start observing changes in "My Outfits" category.
+	//	mCategoriesObserver->addCategory(outfits,
+	//		boost::bind(&LLOutfitsList::refreshList, this, outfits));
 
-	bool onEnable(LLSD::String param)
-	{
-		// Handle the "Wear - Replace Current Outfit" menu option specially
-		// because LLOutfitList::isActionEnabled() checks whether it's allowed
-		// to wear selected outfit OR selected items, while we're only
-		// interested in the outfit (STORM-183).
-		if ("wear" == param)
-		{
-			return LLAppearanceMgr::instance().getCanReplaceCOF(mOutfitList->getSelectedOutfitUUID());
-		}
+	//	const LLUUID cof = gInventory.findCategoryUUIDForType(LLFolderType::FT_CURRENT_OUTFIT);
 
-		return mOutfitList->isActionEnabled(param);
-	}
+	//	// Start observing changes in Current Outfit category.
+	//	mCategoriesObserver->addCategory(cof, boost::bind(&LLOutfitsList::onCOFChanged, this));
 
-	bool onVisible(LLSD::String param)
-	{
-		const LLUUID& selected_outfit_id = getSelectedOutfitID();
-		if (selected_outfit_id.isNull()) // no selection or invalid outfit selected
-		{
-			return false;
-		}
+	//	LLOutfitObserver::instance().addBOFChangedCallback(boost::bind(&LLOutfitsList::highlightBaseOutfit, this));
+	//	LLOutfitObserver::instance().addBOFReplacedCallback(boost::bind(&LLOutfitsList::highlightBaseOutfit, this));
 
-		// *TODO This condition leads to menu item behavior inconsistent with
-		// "Wear" button behavior and should be modified or removed.
-		bool is_worn = LLAppearanceMgr::instance().getBaseOutfitUUID() == selected_outfit_id;
+	//	// Fetch "My Outfits" contents and refresh the list to display
+	//	// initially fetched items. If not all items are fetched now
+	//	// the observer will refresh the list as soon as the new items
+	//	// arrive.
+	//	category->fetch();
+	//	refreshList(outfits);
+	//	highlightBaseOutfit();
 
-		if ("wear" == param)
-		{
-			return !is_worn;
-		}
+	//	mIsInitialized = true;
+	//}
 
-		return true;
-	}
+	LLAccordionCtrlTab* selected_tab = mAccordion->getSelectedTab();
+	if (!selected_tab) return;
 
-	LLOutfitsList*			mOutfitList;
-	LLToggleableMenu*		mMenu;
-};
+	// Pass focus to the selected outfit tab.
+	selected_tab->showAndFocusHeader();
+}
 
-//////////////////////////////////////////////////////////////////////////
 
-class LLOutfitContextMenu : public LLListContextMenu
+void LLOutfitsList::updateAddedCategory(LLUUID cat_id)
 {
-public:
-
-	LLOutfitContextMenu(LLOutfitsList* outfit_list)
-	:		LLListContextMenu(),
-	 		mOutfitList(outfit_list)
-	{}
-protected:
-	/* virtual */ LLContextMenu* createMenu()
-	{
-		LLUICtrl::CommitCallbackRegistry::ScopedRegistrar registrar;
-		LLUICtrl::EnableCallbackRegistry::ScopedRegistrar enable_registrar;
-		LLUUID selected_id = mUUIDs.front();
-
-		registrar.add("Outfit.WearReplace",
-			boost::bind(&LLAppearanceMgr::replaceCurrentOutfit, &LLAppearanceMgr::instance(), selected_id));
-		registrar.add("Outfit.WearAdd",
-			boost::bind(&LLAppearanceMgr::addCategoryToCurrentOutfit, &LLAppearanceMgr::instance(), selected_id));
-		registrar.add("Outfit.TakeOff",
-				boost::bind(&LLAppearanceMgr::takeOffOutfit, &LLAppearanceMgr::instance(), selected_id));
-		registrar.add("Outfit.Edit", boost::bind(editOutfit));
-		registrar.add("Outfit.Rename", boost::bind(renameOutfit, selected_id));
-		registrar.add("Outfit.Delete", boost::bind(&LLOutfitsList::removeSelected, mOutfitList));
-
-		enable_registrar.add("Outfit.OnEnable", boost::bind(&LLOutfitContextMenu::onEnable, this, _2));
-		enable_registrar.add("Outfit.OnVisible", boost::bind(&LLOutfitContextMenu::onVisible, this, _2));
-
-		return createFromFile("menu_outfit_tab.xml");
-	}
+    LLViewerInventoryCategory *cat = gInventory.getCategory(cat_id);
+    if (!cat) return;
 
-	bool onEnable(LLSD::String param)
-	{
-		LLUUID outfit_cat_id = mUUIDs.back();
+    std::string name = cat->getName();
 
-		if ("rename" == param)
-		{
-			return get_is_category_renameable(&gInventory, outfit_cat_id);
-		}
-		else if ("wear_replace" == param)
-		{
-			return LLAppearanceMgr::instance().getCanReplaceCOF(outfit_cat_id);
-		}
-		else if ("wear_add" == param)
-		{
-			return LLAppearanceMgr::getCanAddToCOF(outfit_cat_id);
-		}
-		else if ("take_off" == param)
-		{
-			return LLAppearanceMgr::getCanRemoveFromCOF(outfit_cat_id);
-		}
+    outfit_accordion_tab_params tab_params(get_accordion_tab_params());
+    LLAccordionCtrlTab* tab = LLUICtrlFactory::create<LLAccordionCtrlTab>(tab_params);
+    if (!tab) return;
+    LLWearableItemsList* wearable_list = LLUICtrlFactory::create<LLWearableItemsList>(tab_params.wearable_list);
+    wearable_list->setShape(tab->getLocalRect());
+    tab->addChild(wearable_list);
 
-		return true;
-	}
+    tab->setName(name);
+    tab->setTitle(name);
 
-	bool onVisible(LLSD::String param)
-	{
-		LLUUID outfit_cat_id = mUUIDs.back();
-		bool is_worn = LLAppearanceMgr::instance().getBaseOutfitUUID() == outfit_cat_id;
+    // *TODO: LLUICtrlFactory::defaultBuilder does not use "display_children" from xml. Should be investigated.
+    tab->setDisplayChildren(false);
+    mAccordion->addCollapsibleCtrl(tab);
 
-		if ("edit" == param)
-		{
-			return is_worn;
-		}
-		else if ("wear_replace" == param)
-		{
-			return !is_worn;
-		}
-		else if ("delete" == param)
-		{
-			return LLAppearanceMgr::instance().getCanRemoveOutfit(outfit_cat_id);
-		}
+    // Start observing the new outfit category.
+    LLWearableItemsList* list = tab->getChild<LLWearableItemsList>("wearable_items_list");
+    if (!mCategoriesObserver->addCategory(cat_id, boost::bind(&LLWearableItemsList::updateList, list, cat_id)))
+    {
+        // Remove accordion tab if category could not be added to observer.
+        mAccordion->removeCollapsibleCtrl(tab);
 
-		return true;
-	}
+        // kill removed tab
+        tab->die();
+        return;
+    }
 
-	static void editOutfit()
-	{
-		LLFloaterSidePanelContainer::showPanel("appearance", LLSD().with("type", "edit_outfit"));
-	}
+    // Map the new tab with outfit category UUID.
+    mOutfitsMap.insert(LLOutfitsList::outfits_map_value_t(cat_id, tab));
 
-	static void renameOutfit(const LLUUID& outfit_cat_id)
-	{
-		LLAppearanceMgr::instance().renameOutfit(outfit_cat_id);
-	}
+    tab->setRightMouseDownCallback(boost::bind(&LLOutfitListBase::outfitRightClickCallBack, this,
+        _1, _2, _3, cat_id));
 
-private:
-	LLOutfitsList*	mOutfitList;
-};
+    // Setting tab focus callback to monitor currently selected outfit.
+    tab->setFocusReceivedCallback(boost::bind(&LLOutfitListBase::ñhangeOutfitSelection, this, list, cat_id));
 
-//////////////////////////////////////////////////////////////////////////
+    // Setting callback to reset items selection inside outfit on accordion collapsing and expanding (EXT-7875)
+    tab->setDropDownStateChangedCallback(boost::bind(&LLOutfitsList::resetItemSelection, this, list, cat_id));
 
-static LLPanelInjector<LLOutfitsList> t_outfits_list("outfits_list");
+    // force showing list items that don't match current filter(EXT-7158)
+    list->setForceShowingUnmatchedItems(true);
 
-LLOutfitsList::LLOutfitsList()
-	:	LLPanelAppearanceTab()
-	,	mAccordion(NULL)
-	,	mListCommands(NULL)
-	,	mIsInitialized(false)
-	,	mItemSelected(false)
-{
-	mCategoriesObserver = new LLInventoryCategoriesObserver();
+    // Setting list commit callback to monitor currently selected wearable item.
+    list->setCommitCallback(boost::bind(&LLOutfitsList::onListSelectionChange, this, _1));
 
-	mGearMenu = new LLOutfitListGearMenu(this);
-	mOutfitMenu = new LLOutfitContextMenu(this);
-}
+    // Setting list refresh callback to apply filter on list change.
+    list->setRefreshCompleteCallback(boost::bind(&LLOutfitsList::onFilteredWearableItemsListRefresh, this, _1));
 
-LLOutfitsList::~LLOutfitsList()
-{
-	delete mGearMenu;
-	delete mOutfitMenu;
+    list->setRightMouseDownCallback(boost::bind(&LLOutfitsList::onWearableItemsListRightClick, this, _1, _2, _3));
 
-	if (gInventory.containsObserver(mCategoriesObserver))
-	{
-		gInventory.removeObserver(mCategoriesObserver);
-	}
-	delete mCategoriesObserver;
-}
+    // Fetch the new outfit contents.
+    cat->fetch();
 
-BOOL LLOutfitsList::postBuild()
-{
-	mAccordion = getChild<LLAccordionCtrl>("outfits_accordion");
-	mAccordion->setComparator(&OUTFIT_TAB_NAME_COMPARATOR);
+    // Refresh the list of outfit items after fetch().
+    // Further list updates will be triggered by the category observer.
+    list->updateList(cat_id);
 
-	LLMenuButton* menu_gear_btn = getChild<LLMenuButton>("options_gear_btn");
+    // If filter is currently applied we store the initial tab state and
+    // open it to show matched items if any.
+    if (!sFilterSubString.empty())
+    {
+        tab->notifyChildren(LLSD().with("action", "store_state"));
+        tab->setDisplayChildren(true);
 
-	menu_gear_btn->setMouseDownCallback(boost::bind(&LLOutfitListGearMenu::updateItemsVisibility, mGearMenu));
-	menu_gear_btn->setMenu(mGearMenu->getMenu());
+        // Setting mForceRefresh flag will make the list refresh its contents
+        // even if it is not currently visible. This is required to apply the
+        // filter to the newly added list.
+        list->setForceRefresh(true);
 
-	return TRUE;
+        list->setFilterSubString(sFilterSubString);
+    }
 }
 
-//virtual
-void LLOutfitsList::onOpen(const LLSD& /*info*/)
+void LLOutfitsList::updateRemovedCategory(LLUUID cat_id)
 {
-	if (!mIsInitialized)
-	{
-		// *TODO: I'm not sure is this check necessary but it never match while developing.
-		if (!gInventory.isInventoryUsable())
-			return;
-
-		const LLUUID outfits = gInventory.findCategoryUUIDForType(LLFolderType::FT_MY_OUTFITS);
-
-		// *TODO: I'm not sure is this check necessary but it never match while developing.
-		LLViewerInventoryCategory* category = gInventory.getCategory(outfits);
-		if (!category)
-			return;
-
-		gInventory.addObserver(mCategoriesObserver);
-
-		// Start observing changes in "My Outfits" category.
-		mCategoriesObserver->addCategory(outfits,
-			boost::bind(&LLOutfitsList::refreshList, this, outfits));
-
-		const LLUUID cof = gInventory.findCategoryUUIDForType(LLFolderType::FT_CURRENT_OUTFIT);
-
-		// Start observing changes in Current Outfit category.
-		mCategoriesObserver->addCategory(cof, boost::bind(&LLOutfitsList::onCOFChanged, this));
-
-		LLOutfitObserver::instance().addBOFChangedCallback(boost::bind(&LLOutfitsList::highlightBaseOutfit, this));
-		LLOutfitObserver::instance().addBOFReplacedCallback(boost::bind(&LLOutfitsList::highlightBaseOutfit, this));
-
-		// Fetch "My Outfits" contents and refresh the list to display
-		// initially fetched items. If not all items are fetched now
-		// the observer will refresh the list as soon as the new items
-		// arrive.
-		category->fetch();
-		refreshList(outfits);
-		highlightBaseOutfit();
-
-		mIsInitialized = true;
-	}
-
-	LLAccordionCtrlTab* selected_tab = mAccordion->getSelectedTab();
-	if (!selected_tab) return;
-
-	// Pass focus to the selected outfit tab.
-	selected_tab->showAndFocusHeader();
+    outfits_map_t::iterator outfits_iter = mOutfitsMap.find(cat_id);
+    if (outfits_iter != mOutfitsMap.end())
+    {
+    	const LLUUID& outfit_id = outfits_iter->first;
+    	LLAccordionCtrlTab* tab = outfits_iter->second;
+
+    	// An outfit is removed from the list. Do the following:
+    	// 1. Remove outfit category from observer to stop monitoring its changes.
+    	mCategoriesObserver->removeCategory(outfit_id);
+
+    	// 2. Remove the outfit from selection.
+    	deselectOutfit(outfit_id);
+
+    	// 3. Remove category UUID to accordion tab mapping.
+    	mOutfitsMap.erase(outfits_iter);
+
+    	// 4. Remove outfit tab from accordion.
+    	mAccordion->removeCollapsibleCtrl(tab);
+
+    	// kill removed tab
+    	if (tab != NULL)
+    	{
+    		tab->die();
+    	}
+    }
 }
 
+/*
 void LLOutfitsList::refreshList(const LLUUID& category_id)
 {
 	LLInventoryModel::cat_array_t cat_array;
@@ -457,111 +322,114 @@ void LLOutfitsList::refreshList(const LLUUID& category_id)
 		 ++iter)
 	{
 		const LLUUID cat_id = (*iter);
-		LLViewerInventoryCategory *cat = gInventory.getCategory(cat_id);
-		if (!cat) continue;
+        updateAddedCategory(cat_id);
+		//LLViewerInventoryCategory *cat = gInventory.getCategory(cat_id);
+		//if (!cat) continue;
 
-		std::string name = cat->getName();
+		//std::string name = cat->getName();
 
-		outfit_accordion_tab_params tab_params(get_accordion_tab_params());
-		LLAccordionCtrlTab* tab = LLUICtrlFactory::create<LLAccordionCtrlTab>(tab_params);
-		if (!tab) continue;
-		LLWearableItemsList* wearable_list = LLUICtrlFactory::create<LLWearableItemsList>(tab_params.wearable_list);
-		wearable_list->setShape(tab->getLocalRect());
-		tab->addChild(wearable_list);
+		//outfit_accordion_tab_params tab_params(get_accordion_tab_params());
+		//LLAccordionCtrlTab* tab = LLUICtrlFactory::create<LLAccordionCtrlTab>(tab_params);
+		//if (!tab) continue;
+		//LLWearableItemsList* wearable_list = LLUICtrlFactory::create<LLWearableItemsList>(tab_params.wearable_list);
+		//wearable_list->setShape(tab->getLocalRect());
+		//tab->addChild(wearable_list);
 
-		tab->setName(name);
-		tab->setTitle(name);
+		//tab->setName(name);
+		//tab->setTitle(name);
 
-		// *TODO: LLUICtrlFactory::defaultBuilder does not use "display_children" from xml. Should be investigated.
-		tab->setDisplayChildren(false);
-		mAccordion->addCollapsibleCtrl(tab);
+		//// *TODO: LLUICtrlFactory::defaultBuilder does not use "display_children" from xml. Should be investigated.
+		//tab->setDisplayChildren(false);
+		//mAccordion->addCollapsibleCtrl(tab);
 
-		// Start observing the new outfit category.
-		LLWearableItemsList* list  = tab->getChild<LLWearableItemsList>("wearable_items_list");
-		if (!mCategoriesObserver->addCategory(cat_id, boost::bind(&LLWearableItemsList::updateList, list, cat_id)))
-		{
-			// Remove accordion tab if category could not be added to observer.
-			mAccordion->removeCollapsibleCtrl(tab);
+		//// Start observing the new outfit category.
+		//LLWearableItemsList* list  = tab->getChild<LLWearableItemsList>("wearable_items_list");
+		//if (!mCategoriesObserver->addCategory(cat_id, boost::bind(&LLWearableItemsList::updateList, list, cat_id)))
+		//{
+		//	// Remove accordion tab if category could not be added to observer.
+		//	mAccordion->removeCollapsibleCtrl(tab);
 
-			// kill removed tab
-				tab->die();
-			continue;
-		}
+		//	// kill removed tab
+		//		tab->die();
+		//	continue;
+		//}
 
-		// Map the new tab with outfit category UUID.
-		mOutfitsMap.insert(LLOutfitsList::outfits_map_value_t(cat_id, tab));
+		//// Map the new tab with outfit category UUID.
+		//mOutfitsMap.insert(LLOutfitsList::outfits_map_value_t(cat_id, tab));
 
-		tab->setRightMouseDownCallback(boost::bind(&LLOutfitsList::onAccordionTabRightClick, this,
-			_1, _2, _3, cat_id));
+		//tab->setRightMouseDownCallback(boost::bind(&LLOutfitsList::onAccordionTabRightClick, this,
+		//	_1, _2, _3, cat_id));
 
-		// Setting tab focus callback to monitor currently selected outfit.
-		tab->setFocusReceivedCallback(boost::bind(&LLOutfitsList::changeOutfitSelection, this, list, cat_id));
+		//// Setting tab focus callback to monitor currently selected outfit.
+		//tab->setFocusReceivedCallback(boost::bind(&LLOutfitsList::changeOutfitSelection, this, list, cat_id));
 
-		// Setting callback to reset items selection inside outfit on accordion collapsing and expanding (EXT-7875)
-		tab->setDropDownStateChangedCallback(boost::bind(&LLOutfitsList::resetItemSelection, this, list, cat_id));
+		//// Setting callback to reset items selection inside outfit on accordion collapsing and expanding (EXT-7875)
+		//tab->setDropDownStateChangedCallback(boost::bind(&LLOutfitsList::resetItemSelection, this, list, cat_id));
 
-		// force showing list items that don't match current filter(EXT-7158)
-		list->setForceShowingUnmatchedItems(true);
+		//// force showing list items that don't match current filter(EXT-7158)
+		//list->setForceShowingUnmatchedItems(true);
 
-		// Setting list commit callback to monitor currently selected wearable item.
-		list->setCommitCallback(boost::bind(&LLOutfitsList::onSelectionChange, this, _1));
+		//// Setting list commit callback to monitor currently selected wearable item.
+		//list->setCommitCallback(boost::bind(&LLOutfitsList::onSelectionChange, this, _1));
 
-		// Setting list refresh callback to apply filter on list change.
-		list->setRefreshCompleteCallback(boost::bind(&LLOutfitsList::onFilteredWearableItemsListRefresh, this, _1));
+		//// Setting list refresh callback to apply filter on list change.
+		//list->setRefreshCompleteCallback(boost::bind(&LLOutfitsList::onFilteredWearableItemsListRefresh, this, _1));
 
-		list->setRightMouseDownCallback(boost::bind(&LLOutfitsList::onWearableItemsListRightClick, this, _1, _2, _3));
+		//list->setRightMouseDownCallback(boost::bind(&LLOutfitsList::onWearableItemsListRightClick, this, _1, _2, _3));
 
-		// Fetch the new outfit contents.
-		cat->fetch();
+		//// Fetch the new outfit contents.
+		//cat->fetch();
 
-		// Refresh the list of outfit items after fetch().
-		// Further list updates will be triggered by the category observer.
-		list->updateList(cat_id);
+		//// Refresh the list of outfit items after fetch().
+		//// Further list updates will be triggered by the category observer.
+		//list->updateList(cat_id);
 
-		// If filter is currently applied we store the initial tab state and
-		// open it to show matched items if any.
-		if (!sFilterSubString.empty())
-		{
-			tab->notifyChildren(LLSD().with("action","store_state"));
-			tab->setDisplayChildren(true);
+		//// If filter is currently applied we store the initial tab state and
+		//// open it to show matched items if any.
+		//if (!sFilterSubString.empty())
+		//{
+		//	tab->notifyChildren(LLSD().with("action","store_state"));
+		//	tab->setDisplayChildren(true);
 
-			// Setting mForceRefresh flag will make the list refresh its contents
-			// even if it is not currently visible. This is required to apply the
-			// filter to the newly added list.
-			list->setForceRefresh(true);
+		//	// Setting mForceRefresh flag will make the list refresh its contents
+		//	// even if it is not currently visible. This is required to apply the
+		//	// filter to the newly added list.
+		//	list->setForceRefresh(true);
 
-			list->setFilterSubString(sFilterSubString);
-		}
+		//	list->setFilterSubString(sFilterSubString);
+		//}
 	}
 
 	// Handle removed tabs.
 	for (uuid_vec_t::const_iterator iter=vremoved.begin(); iter != vremoved.end(); ++iter)
 	{
-		outfits_map_t::iterator outfits_iter = mOutfitsMap.find((*iter));
-		if (outfits_iter != mOutfitsMap.end())
-		{
-			const LLUUID& outfit_id = outfits_iter->first;
-			LLAccordionCtrlTab* tab = outfits_iter->second;
-
-			// An outfit is removed from the list. Do the following:
-			// 1. Remove outfit category from observer to stop monitoring its changes.
-			mCategoriesObserver->removeCategory(outfit_id);
-
-			// 2. Remove the outfit from selection.
-			deselectOutfit(outfit_id);
-
-			// 3. Remove category UUID to accordion tab mapping.
-			mOutfitsMap.erase(outfits_iter);
-
-			// 4. Remove outfit tab from accordion.
-			mAccordion->removeCollapsibleCtrl(tab);
-
-			// kill removed tab
-			if (tab != NULL)
-			{
-				tab->die();
-			}
-		}
+        const LLUUID cat_id = (*iter);
+        updateRemovedCategory(cat_id);
+        //outfits_map_t::iterator outfits_iter = mOutfitsMap.find(cat_id);
+		//if (outfits_iter != mOutfitsMap.end())
+		//{
+		//	const LLUUID& outfit_id = outfits_iter->first;
+		//	LLAccordionCtrlTab* tab = outfits_iter->second;
+
+		//	// An outfit is removed from the list. Do the following:
+		//	// 1. Remove outfit category from observer to stop monitoring its changes.
+		//	mCategoriesObserver->removeCategory(outfit_id);
+
+		//	// 2. Remove the outfit from selection.
+		//	deselectOutfit(outfit_id);
+
+		//	// 3. Remove category UUID to accordion tab mapping.
+		//	mOutfitsMap.erase(outfits_iter);
+
+		//	// 4. Remove outfit tab from accordion.
+		//	mAccordion->removeCollapsibleCtrl(tab);
+
+		//	// kill removed tab
+		//	if (tab != NULL)
+		//	{
+		//		tab->die();
+		//	}
+		//}
 	}
 
 	// Get changed items from inventory model and update outfit tabs
@@ -571,34 +439,29 @@ void LLOutfitsList::refreshList(const LLUUID& category_id)
 		 items_iter != changed_items.end();
 		 ++items_iter)
 	{
-		updateOutfitTab(*items_iter);
+		updateChangedCategoryName(*items_iter);
 	}
 
 	mAccordion->sort();
 }
+*/
 
-void LLOutfitsList::highlightBaseOutfit()
+//virtual
+void LLOutfitsList::onHighlightBaseOutfit(LLUUID base_id, LLUUID prev_id)
 {
-	// id of base outfit
-	LLUUID base_id = LLAppearanceMgr::getInstance()->getBaseOutfitUUID();
-	if (base_id != mHighlightedOutfitUUID)
-	{
-		if (mOutfitsMap[mHighlightedOutfitUUID])
-		{
-			mOutfitsMap[mHighlightedOutfitUUID]->setTitleFontStyle("NORMAL");
-			mOutfitsMap[mHighlightedOutfitUUID]->setTitleColor(LLUIColorTable::instance().getColor("AccordionHeaderTextColor"));
-		}
-
-		mHighlightedOutfitUUID = base_id;
-	}
-	if (mOutfitsMap[base_id])
+    if (mOutfitsMap[prev_id])
+    {
+        mOutfitsMap[prev_id]->setTitleFontStyle("NORMAL");
+        mOutfitsMap[prev_id]->setTitleColor(LLUIColorTable::instance().getColor("AccordionHeaderTextColor"));
+    }
+    if (mOutfitsMap[base_id])
 	{
 		mOutfitsMap[base_id]->setTitleFontStyle("BOLD");
 		mOutfitsMap[base_id]->setTitleColor(LLUIColorTable::instance().getColor("SelectedOutfitTextColor"));
 	}
 }
 
-void LLOutfitsList::onSelectionChange(LLUICtrl* ctrl)
+void LLOutfitsList::onListSelectionChange(LLUICtrl* ctrl)
 {
 	LLWearableItemsList* list = dynamic_cast<LLWearableItemsList*>(ctrl);
 	if (!list) return;
@@ -606,10 +469,10 @@ void LLOutfitsList::onSelectionChange(LLUICtrl* ctrl)
 	LLViewerInventoryItem *item = gInventory.getItem(list->getSelectedUUID());
 	if (!item) return;
 
-	changeOutfitSelection(list, item->getParentUUID());
+	ñhangeOutfitSelection(list, item->getParentUUID());
 }
 
-void LLOutfitsList::performAction(std::string action)
+void LLOutfitListBase::performAction(std::string action)
 {
 	if (mSelectedOutfitUUID.isNull()) return;
 
@@ -630,23 +493,7 @@ void LLOutfitsList::performAction(std::string action)
 	}
 }
 
-void LLOutfitsList::removeSelected()
-{
-	LLNotificationsUtil::add("DeleteOutfits", LLSD(), LLSD(), boost::bind(&LLOutfitsList::onOutfitsRemovalConfirmation, this, _1, _2));
-}
-
-void LLOutfitsList::onOutfitsRemovalConfirmation(const LLSD& notification, const LLSD& response)
-{
-	S32 option = LLNotificationsUtil::getSelectedOption(notification, response);
-	if (option != 0) return; // canceled
-
-	if (mSelectedOutfitUUID.notNull())
-	{
-		gInventory.removeCategory(mSelectedOutfitUUID);
-	}
-}
-
-void LLOutfitsList::setSelectedOutfitByUUID(const LLUUID& outfit_uuid)
+void LLOutfitsList::onSetSelectedOutfitByUUID(const LLUUID& outfit_uuid)
 {
 	for (outfits_map_t::iterator iter = mOutfitsMap.begin();
 			iter != mOutfitsMap.end();
@@ -661,7 +508,7 @@ void LLOutfitsList::setSelectedOutfitByUUID(const LLUUID& outfit_uuid)
 			if (!list) continue;
 
 			tab->setFocus(TRUE);
-			changeOutfitSelection(list, outfit_uuid);
+			ñhangeOutfitSelection(list, outfit_uuid);
 
 			tab->setDisplayChildren(true);
 		}
@@ -677,14 +524,14 @@ void LLOutfitsList::setFilterSubString(const std::string& string)
 }
 
 // virtual
-bool LLOutfitsList::isActionEnabled(const LLSD& userdata)
+bool LLOutfitListBase::isActionEnabled(const LLSD& userdata)
 {
 	if (mSelectedOutfitUUID.isNull()) return false;
 
 	const std::string command_name = userdata.asString();
 	if (command_name == "delete")
 	{
-		return !mItemSelected && LLAppearanceMgr::instance().getCanRemoveOutfit(mSelectedOutfitUUID);
+        return !hasItemSelected() && LLAppearanceMgr::instance().getCanRemoveOutfit(mSelectedOutfitUUID);
 	}
 	if (command_name == "rename")
 	{
@@ -745,7 +592,7 @@ void LLOutfitsList::getSelectedItemsUUIDs(uuid_vec_t& selected_uuids) const
 	}
 }
 
-void LLOutfitsList::collapse_all_folders()
+void LLOutfitsList::onCollapseAllFolders()
 {
 	for (outfits_map_t::iterator iter = mOutfitsMap.begin();
 			iter != mOutfitsMap.end();
@@ -759,7 +606,7 @@ void LLOutfitsList::collapse_all_folders()
 	}
 }
 
-void LLOutfitsList::expand_all_folders()
+void LLOutfitsList::onExpandAllFolders()
 {
 	for (outfits_map_t::iterator iter = mOutfitsMap.begin();
 			iter != mOutfitsMap.end();
@@ -773,11 +620,6 @@ void LLOutfitsList::expand_all_folders()
 	}
 }
 
-boost::signals2::connection LLOutfitsList::setSelectionChangeCallback(selection_change_callback_t cb)
-{
-	return mSelectionChangeSignal.connect(cb);
-}
-
 bool LLOutfitsList::hasItemSelected()
 {
 	return mItemSelected;
@@ -786,6 +628,7 @@ bool LLOutfitsList::hasItemSelected()
 //////////////////////////////////////////////////////////////////////////
 // Private methods
 //////////////////////////////////////////////////////////////////////////
+/*
 void LLOutfitsList::computeDifference(
 	const LLInventoryModel::cat_array_t& vcats, 
 	uuid_vec_t& vadded, 
@@ -811,17 +654,13 @@ void LLOutfitsList::computeDifference(
 
 	LLCommonUtils::computeDifference(vnew, vcur, vadded, vremoved);
 }
+*/
 
-void LLOutfitsList::updateOutfitTab(const LLUUID& category_id)
+void LLOutfitsList::updateChangedCategoryName(LLViewerInventoryCategory *cat, std::string name)
 {
-	outfits_map_t::iterator outfits_iter = mOutfitsMap.find(category_id);
+    outfits_map_t::iterator outfits_iter = mOutfitsMap.find(cat->getUUID());
 	if (outfits_iter != mOutfitsMap.end())
 	{
-		LLViewerInventoryCategory *cat = gInventory.getCategory(category_id);
-		if (!cat) return;
-
-		std::string name = cat->getName();
-
 		// Update tab name with the new category name.
 		LLAccordionCtrlTab* tab = outfits_iter->second;
 		if (tab)
@@ -836,10 +675,10 @@ void LLOutfitsList::resetItemSelection(LLWearableItemsList* list, const LLUUID&
 {
 	list->resetSelection();
 	mItemSelected = false;
-	setSelectedOutfitUUID(category_id);
+	signalSelectionOutfitUUID(category_id);
 }
 
-void LLOutfitsList::changeOutfitSelection(LLWearableItemsList* list, const LLUUID& category_id)
+void LLOutfitsList::onChangeOutfitSelection(LLWearableItemsList* list, const LLUUID& category_id)
 {
 	MASK mask = gKeyboard->currentMask(TRUE);
 
@@ -865,12 +704,6 @@ void LLOutfitsList::changeOutfitSelection(LLWearableItemsList* list, const LLUUI
 	mItemSelected = list && (list->getSelectedItem() != NULL);
 
 	mSelectedListsMap.insert(wearables_lists_map_value_t(category_id, list));
-	setSelectedOutfitUUID(category_id);
-}
-
-void LLOutfitsList::setSelectedOutfitUUID(const LLUUID& category_id)
-{
-	mSelectionChangeSignal(mSelectedOutfitUUID = category_id);
 }
 
 void LLOutfitsList::deselectOutfit(const LLUUID& category_id)
@@ -881,7 +714,7 @@ void LLOutfitsList::deselectOutfit(const LLUUID& category_id)
 	// Reset selection if the outfit is selected.
 	if (category_id == mSelectedOutfitUUID)
 	{
-		setSelectedOutfitUUID(LLUUID::null);
+		signalSelectionOutfitUUID(LLUUID::null);
 	}
 }
 
@@ -890,7 +723,7 @@ void LLOutfitsList::restoreOutfitSelection(LLAccordionCtrlTab* tab, const LLUUID
 	// Try restoring outfit selection after filtering.
 	if (mAccordion->getSelectedTab() == tab)
 	{
-		setSelectedOutfitUUID(category_id);
+		signalSelectionOutfitUUID(category_id);
 	}
 }
 
@@ -1036,24 +869,6 @@ bool LLOutfitsList::canWearSelected()
 	return true;
 }
 
-void LLOutfitsList::onAccordionTabRightClick(LLUICtrl* ctrl, S32 x, S32 y, const LLUUID& cat_id)
-{
-	LLAccordionCtrlTab* tab = dynamic_cast<LLAccordionCtrlTab*>(ctrl);
-	if(mOutfitMenu && is_tab_header_clicked(tab, y) && cat_id.notNull())
-	{
-		// Focus tab header to trigger tab selection change.
-		LLUICtrl* header = tab->findChild<LLUICtrl>("dd_header");
-		if (header)
-		{
-			header->setFocus(TRUE);
-		}
-
-		uuid_vec_t selected_uuids;
-		selected_uuids.push_back(cat_id);
-		mOutfitMenu->show(ctrl, selected_uuids, x, y);
-	}
-}
-
 void LLOutfitsList::wearSelectedItems()
 {
 	uuid_vec_t selected_uuids;
@@ -1132,6 +947,47 @@ void LLOutfitsList::onCOFChanged()
 	}
 }
 
+void LLOutfitsList::getCurrentCategories(uuid_vec_t& vcur)
+{
+    // Creating a vector of currently displayed sub-categories UUIDs.
+    for (outfits_map_t::const_iterator iter = mOutfitsMap.begin();
+        iter != mOutfitsMap.end();
+        iter++)
+    {
+        vcur.push_back((*iter).first);
+    }
+}
+
+
+void LLOutfitsList::sortOutfits()
+{
+    mAccordion->sort();
+}
+
+void LLOutfitsList::onOutfitRightClick(LLUICtrl* ctrl, S32 x, S32 y, const LLUUID& cat_id)
+{
+    LLAccordionCtrlTab* tab = dynamic_cast<LLAccordionCtrlTab*>(ctrl);
+    if (mOutfitMenu && is_tab_header_clicked(tab, y) && cat_id.notNull())
+    {
+        // Focus tab header to trigger tab selection change.
+        LLUICtrl* header = tab->findChild<LLUICtrl>("dd_header");
+        if (header)
+        {
+            header->setFocus(TRUE);
+        }
+
+        uuid_vec_t selected_uuids;
+        selected_uuids.push_back(cat_id);
+        mOutfitMenu->show(ctrl, selected_uuids, x, y);
+    }
+}
+
+LLOutfitListGearMenuBase* LLOutfitsList::createGearMenu()
+{
+    return new LLOutfitListGearMenu(this);
+}
+
+
 bool is_tab_header_clicked(LLAccordionCtrlTab* tab, S32 y)
 {
 	if(!tab || !tab->getHeaderVisible()) return false;
@@ -1140,4 +996,490 @@ bool is_tab_header_clicked(LLAccordionCtrlTab* tab, S32 y)
 	return y >= header_bottom;
 }
 
+LLOutfitListBase::LLOutfitListBase()
+    :   LLPanelAppearanceTab()
+    ,   mIsInitialized(false)
+{
+    mCategoriesObserver = new LLInventoryCategoriesObserver();
+    mOutfitMenu = new LLOutfitContextMenu(this);
+    //mGearMenu = createGearMenu();
+}
+
+LLOutfitListBase::~LLOutfitListBase()
+{
+    delete mOutfitMenu;
+    delete mGearMenu;
+
+    if (gInventory.containsObserver(mCategoriesObserver))
+    {
+        gInventory.removeObserver(mCategoriesObserver);
+    }
+    delete mCategoriesObserver;
+}
+
+void LLOutfitListBase::onOpen(const LLSD& info)
+{
+    if (!mIsInitialized)
+    {
+        // *TODO: I'm not sure is this check necessary but it never match while developing.
+        if (!gInventory.isInventoryUsable())
+            return;
+
+        const LLUUID outfits = gInventory.findCategoryUUIDForType(LLFolderType::FT_MY_OUTFITS);
+
+        // *TODO: I'm not sure is this check necessary but it never match while developing.
+        LLViewerInventoryCategory* category = gInventory.getCategory(outfits);
+        if (!category)
+            return;
+
+        gInventory.addObserver(mCategoriesObserver);
+
+        // Start observing changes in "My Outfits" category.
+        mCategoriesObserver->addCategory(outfits,
+            boost::bind(&LLOutfitListBase::refreshList, this, outfits));
+
+        const LLUUID cof = gInventory.findCategoryUUIDForType(LLFolderType::FT_CURRENT_OUTFIT);
+
+        // Start observing changes in Current Outfit category.
+        //mCategoriesObserver->addCategory(cof, boost::bind(&LLOutfitsList::onCOFChanged, this));
+
+        LLOutfitObserver::instance().addBOFChangedCallback(boost::bind(&LLOutfitListBase::highlightBaseOutfit, this));
+        LLOutfitObserver::instance().addBOFReplacedCallback(boost::bind(&LLOutfitListBase::highlightBaseOutfit, this));
+
+        // Fetch "My Outfits" contents and refresh the list to display
+        // initially fetched items. If not all items are fetched now
+        // the observer will refresh the list as soon as the new items
+        // arrive.
+        category->fetch();
+        refreshList(outfits);
+        highlightBaseOutfit();
+
+        mIsInitialized = true;
+    }
+
+    //LLAccordionCtrlTab* selected_tab = mAccordion->getSelectedTab();
+    //if (!selected_tab) return;
+
+    //// Pass focus to the selected outfit tab.
+    //selected_tab->showAndFocusHeader();
+}
+
+void LLOutfitListBase::refreshList(const LLUUID& category_id)
+{
+    LLInventoryModel::cat_array_t cat_array;
+    LLInventoryModel::item_array_t item_array;
+
+    // Collect all sub-categories of a given category.
+    LLIsType is_category(LLAssetType::AT_CATEGORY);
+    gInventory.collectDescendentsIf(
+        category_id,
+        cat_array,
+        item_array,
+        LLInventoryModel::EXCLUDE_TRASH,
+        is_category);
+
+    uuid_vec_t vadded;
+    uuid_vec_t vremoved;
+
+    // Create added and removed items vectors.
+    computeDifference(cat_array, vadded, vremoved);
+
+    // Handle added tabs.
+    for (uuid_vec_t::const_iterator iter = vadded.begin();
+        iter != vadded.end();
+        ++iter)
+    {
+        const LLUUID cat_id = (*iter);
+        updateAddedCategory(cat_id);
+    }
+
+    // Handle removed tabs.
+    for (uuid_vec_t::const_iterator iter = vremoved.begin(); iter != vremoved.end(); ++iter)
+    {
+        const LLUUID cat_id = (*iter);
+        updateRemovedCategory(cat_id);
+    }
+
+    // Get changed items from inventory model and update outfit tabs
+    // which might have been renamed.
+    const LLInventoryModel::changed_items_t& changed_items = gInventory.getChangedIDs();
+    for (LLInventoryModel::changed_items_t::const_iterator items_iter = changed_items.begin();
+        items_iter != changed_items.end();
+        ++items_iter)
+    {
+        LLViewerInventoryCategory *cat = gInventory.getCategory(*items_iter);
+        if (!cat) return;
+
+        std::string name = cat->getName();
+
+        updateChangedCategoryName(cat, name);
+    }
+
+    sortOutfits();
+}
+
+void LLOutfitListBase::computeDifference(
+    const LLInventoryModel::cat_array_t& vcats,
+    uuid_vec_t& vadded,
+    uuid_vec_t& vremoved)
+{
+    uuid_vec_t vnew;
+    // Creating a vector of newly collected sub-categories UUIDs.
+    for (LLInventoryModel::cat_array_t::const_iterator iter = vcats.begin();
+        iter != vcats.end();
+        iter++)
+    {
+        vnew.push_back((*iter)->getUUID());
+    }
+
+    uuid_vec_t vcur;
+    //// Creating a vector of currently displayed sub-categories UUIDs.
+    //for (outfits_map_t::const_iterator iter = mOutfitsMap.begin();
+    //    iter != mOutfitsMap.end();
+    //    iter++)
+    //{
+    //    vcur.push_back((*iter).first);
+    //}
+    getCurrentCategories(vcur);
+
+    LLCommonUtils::computeDifference(vnew, vcur, vadded, vremoved);
+}
+
+void LLOutfitListBase::sortOutfits()
+{
+}
+
+void LLOutfitListBase::highlightBaseOutfit()
+{
+    // id of base outfit
+    LLUUID base_id = LLAppearanceMgr::getInstance()->getBaseOutfitUUID();
+    if (base_id != mHighlightedOutfitUUID)
+    {
+        LLUUID prev_id = mHighlightedOutfitUUID;
+        mHighlightedOutfitUUID = base_id;
+        onHighlightBaseOutfit(base_id, prev_id);
+    }
+
+}
+
+void LLOutfitListBase::removeSelected()
+{
+    LLNotificationsUtil::add("DeleteOutfits", LLSD(), LLSD(), boost::bind(&LLOutfitListBase::onOutfitsRemovalConfirmation, this, _1, _2));
+}
+
+void LLOutfitListBase::onOutfitsRemovalConfirmation(const LLSD& notification, const LLSD& response)
+{
+    S32 option = LLNotificationsUtil::getSelectedOption(notification, response);
+    if (option != 0) return; // canceled
+
+    if (mSelectedOutfitUUID.notNull())
+    {
+        gInventory.removeCategory(mSelectedOutfitUUID);
+    }
+}
+
+void LLOutfitListBase::setSelectedOutfitByUUID(const LLUUID& outfit_uuid)
+{
+    onSetSelectedOutfitByUUID(outfit_uuid);
+}
+
+boost::signals2::connection LLOutfitListBase::setSelectionChangeCallback(selection_change_callback_t cb)
+{
+    return mSelectionChangeSignal.connect(cb);
+}
+
+void LLOutfitListBase::signalSelectionOutfitUUID(const LLUUID& category_id)
+{
+    mSelectionChangeSignal(category_id);
+}
+
+void LLOutfitListBase::outfitRightClickCallBack(LLUICtrl* ctrl, S32 x, S32 y, const LLUUID& cat_id)
+{
+    onOutfitRightClick(ctrl, x, y, cat_id);
+}
+
+void LLOutfitListBase::ñhangeOutfitSelection(LLWearableItemsList* list, const LLUUID& category_id)
+{
+    onChangeOutfitSelection(list, category_id);
+    mSelectedOutfitUUID = category_id;
+    signalSelectionOutfitUUID(category_id);
+}
+
+BOOL LLOutfitListBase::postBuild()
+{
+    mGearMenu = createGearMenu();
+
+    LLMenuButton* menu_gear_btn = getChild<LLMenuButton>("options_gear_btn");
+
+    menu_gear_btn->setMouseDownCallback(boost::bind(&LLOutfitListGearMenuBase::updateItemsVisibility, mGearMenu));
+    menu_gear_btn->setMenu(mGearMenu->getMenu());
+    return TRUE;
+}
+
+void LLOutfitListBase::collapseAllFolders()
+{
+    onCollapseAllFolders();
+}
+
+void LLOutfitListBase::expandAllFolders()
+{
+    onExpandAllFolders();
+}
+
+LLContextMenu* LLOutfitContextMenu::createMenu()
+{
+    LLUICtrl::CommitCallbackRegistry::ScopedRegistrar registrar;
+    LLUICtrl::EnableCallbackRegistry::ScopedRegistrar enable_registrar;
+    LLUUID selected_id = mUUIDs.front();
+
+    registrar.add("Outfit.WearReplace",
+        boost::bind(&LLAppearanceMgr::replaceCurrentOutfit, &LLAppearanceMgr::instance(), selected_id));
+    registrar.add("Outfit.WearAdd",
+        boost::bind(&LLAppearanceMgr::addCategoryToCurrentOutfit, &LLAppearanceMgr::instance(), selected_id));
+    registrar.add("Outfit.TakeOff",
+        boost::bind(&LLAppearanceMgr::takeOffOutfit, &LLAppearanceMgr::instance(), selected_id));
+    registrar.add("Outfit.Edit", boost::bind(editOutfit));
+    registrar.add("Outfit.Rename", boost::bind(renameOutfit, selected_id));
+    registrar.add("Outfit.Delete", boost::bind(&LLOutfitListBase::removeSelected, mOutfitList));
+
+    enable_registrar.add("Outfit.OnEnable", boost::bind(&LLOutfitContextMenu::onEnable, this, _2));
+    enable_registrar.add("Outfit.OnVisible", boost::bind(&LLOutfitContextMenu::onVisible, this, _2));
+
+    return createFromFile("menu_outfit_tab.xml");
+
+}
+
+bool LLOutfitContextMenu::onEnable(LLSD::String param)
+{
+    LLUUID outfit_cat_id = mUUIDs.back();
+
+    if ("rename" == param)
+    {
+        return get_is_category_renameable(&gInventory, outfit_cat_id);
+    }
+    else if ("wear_replace" == param)
+    {
+        return LLAppearanceMgr::instance().getCanReplaceCOF(outfit_cat_id);
+    }
+    else if ("wear_add" == param)
+    {
+        return LLAppearanceMgr::getCanAddToCOF(outfit_cat_id);
+    }
+    else if ("take_off" == param)
+    {
+        return LLAppearanceMgr::getCanRemoveFromCOF(outfit_cat_id);
+    }
+
+    return true;
+}
+
+bool LLOutfitContextMenu::onVisible(LLSD::String param)
+{
+    LLUUID outfit_cat_id = mUUIDs.back();
+    bool is_worn = LLAppearanceMgr::instance().getBaseOutfitUUID() == outfit_cat_id;
+
+    if ("edit" == param)
+    {
+        return is_worn;
+    }
+    else if ("wear_replace" == param)
+    {
+        return !is_worn;
+    }
+    else if ("delete" == param)
+    {
+        return LLAppearanceMgr::instance().getCanRemoveOutfit(outfit_cat_id);
+    }
+
+    return true;
+}
+
+//static
+void LLOutfitContextMenu::editOutfit()
+{
+    LLFloaterSidePanelContainer::showPanel("appearance", LLSD().with("type", "edit_outfit"));
+}
+
+void LLOutfitContextMenu::renameOutfit(const LLUUID& outfit_cat_id)
+{
+    LLAppearanceMgr::instance().renameOutfit(outfit_cat_id);
+}
+
+LLOutfitListGearMenuBase::LLOutfitListGearMenuBase(LLOutfitListBase* olist)
+    :   mOutfitList(olist),
+        mMenu(NULL)
+{
+    llassert_always(mOutfitList);
+
+    LLUICtrl::CommitCallbackRegistry::ScopedRegistrar registrar;
+    LLUICtrl::EnableCallbackRegistry::ScopedRegistrar enable_registrar;
+
+    registrar.add("Gear.Wear", boost::bind(&LLOutfitListGearMenuBase::onWear, this));
+    registrar.add("Gear.TakeOff", boost::bind(&LLOutfitListGearMenuBase::onTakeOff, this));
+    registrar.add("Gear.Rename", boost::bind(&LLOutfitListGearMenuBase::onRename, this));
+    registrar.add("Gear.Delete", boost::bind(&LLOutfitListBase::removeSelected, mOutfitList));
+    registrar.add("Gear.Create", boost::bind(&LLOutfitListGearMenuBase::onCreate, this, _2));
+    registrar.add("Gear.Collapse", boost::bind(&LLOutfitListBase::onCollapseAllFolders, mOutfitList));
+    registrar.add("Gear.Expand", boost::bind(&LLOutfitListBase::onExpandAllFolders, mOutfitList));
+
+    registrar.add("Gear.WearAdd", boost::bind(&LLOutfitListGearMenuBase::onAdd, this));
+
+    registrar.add("Gear.UploadFoto", boost::bind(&LLOutfitListGearMenuBase::onUploadFoto, this));
+    registrar.add("Gear.LoadAssets", boost::bind(&LLOutfitListGearMenuBase::onLoadAssets, this));
+    
+    enable_registrar.add("Gear.OnEnable", boost::bind(&LLOutfitListGearMenuBase::onEnable, this, _2));
+    enable_registrar.add("Gear.OnVisible", boost::bind(&LLOutfitListGearMenuBase::onVisible, this, _2));
+
+    mMenu = LLUICtrlFactory::getInstance()->createFromFile<LLToggleableMenu>(
+        "menu_outfit_gear.xml", gMenuHolder, LLViewerMenuHolderGL::child_registry_t::instance());
+    llassert(mMenu);
+}
+
+void LLOutfitListGearMenuBase::updateItemsVisibility()
+{
+    onUpdateItemsVisibility();
+}
+
+void LLOutfitListGearMenuBase::onUpdateItemsVisibility()
+{
+    if (!mMenu) return;
+
+    bool have_selection = getSelectedOutfitID().notNull();
+    mMenu->setItemVisible("sepatator1", have_selection);
+    mMenu->setItemVisible("sepatator2", have_selection);
+    //mMenu->setItemVisible("expand", mOutfitList->getHasExpandableFolders());
+    //mMenu->setItemVisible("collapse", mOutfitList->getHasExpandableFolders());
+    mMenu->arrangeAndClear(); // update menu height
+}
+
+LLToggleableMenu* LLOutfitListGearMenuBase::getMenu()
+{
+    return mMenu;
+}
+const LLUUID& LLOutfitListGearMenuBase::getSelectedOutfitID()
+{
+    return mOutfitList->getSelectedOutfitUUID();
+}
+
+LLViewerInventoryCategory* LLOutfitListGearMenuBase::getSelectedOutfit()
+{
+    const LLUUID& selected_outfit_id = getSelectedOutfitID();
+    if (selected_outfit_id.isNull())
+    {
+        return NULL;
+    }
+
+    LLViewerInventoryCategory* cat = gInventory.getCategory(selected_outfit_id);
+    return cat;
+}
+
+void LLOutfitListGearMenuBase::onWear()
+{
+    LLViewerInventoryCategory* selected_outfit = getSelectedOutfit();
+    if (selected_outfit)
+    {
+        LLAppearanceMgr::instance().wearInventoryCategory(
+            selected_outfit, /*copy=*/ FALSE, /*append=*/ FALSE);
+    }
+}
+
+void LLOutfitListGearMenuBase::onAdd()
+{
+    const LLUUID& selected_id = getSelectedOutfitID();
+
+    if (selected_id.notNull())
+    {
+        LLAppearanceMgr::getInstance()->addCategoryToCurrentOutfit(selected_id);
+    }
+}
+
+void LLOutfitListGearMenuBase::onTakeOff()
+{
+    // Take off selected outfit.
+    const LLUUID& selected_outfit_id = getSelectedOutfitID();
+    if (selected_outfit_id.notNull())
+    {
+        LLAppearanceMgr::instance().takeOffOutfit(selected_outfit_id);
+    }
+}
+
+void LLOutfitListGearMenuBase::onRename()
+{
+    const LLUUID& selected_outfit_id = getSelectedOutfitID();
+    if (selected_outfit_id.notNull())
+    {
+        LLAppearanceMgr::instance().renameOutfit(selected_outfit_id);
+    }
+}
+
+void LLOutfitListGearMenuBase::onCreate(const LLSD& data)
+{
+    LLWearableType::EType type = LLWearableType::typeNameToType(data.asString());
+    if (type == LLWearableType::WT_NONE)
+    {
+        LL_WARNS() << "Invalid wearable type" << LL_ENDL;
+        return;
+    }
+
+    LLAgentWearables::createWearable(type, true);
+}
+
+bool LLOutfitListGearMenuBase::onEnable(LLSD::String param)
+{
+    // Handle the "Wear - Replace Current Outfit" menu option specially
+    // because LLOutfitList::isActionEnabled() checks whether it's allowed
+    // to wear selected outfit OR selected items, while we're only
+    // interested in the outfit (STORM-183).
+    if ("wear" == param)
+    {
+        return LLAppearanceMgr::instance().getCanReplaceCOF(mOutfitList->getSelectedOutfitUUID());
+    }
+
+    return mOutfitList->isActionEnabled(param);
+}
+
+bool LLOutfitListGearMenuBase::onVisible(LLSD::String param)
+{
+    const LLUUID& selected_outfit_id = getSelectedOutfitID();
+    if (selected_outfit_id.isNull()) // no selection or invalid outfit selected
+    {
+        return false;
+    }
+
+    // *TODO This condition leads to menu item behavior inconsistent with
+    // "Wear" button behavior and should be modified or removed.
+    bool is_worn = LLAppearanceMgr::instance().getBaseOutfitUUID() == selected_outfit_id;
+
+    if ("wear" == param)
+    {
+        return !is_worn;
+    }
+
+    return true;
+}
+
+void LLOutfitListGearMenuBase::onUploadFoto()
+{
+
+}
+
+void LLOutfitListGearMenuBase::onLoadAssets()
+{
+
+}
+
+LLOutfitListGearMenu::LLOutfitListGearMenu(LLOutfitListBase* olist)
+    : LLOutfitListGearMenuBase(olist)
+{}
+
+void LLOutfitListGearMenu::onUpdateItemsVisibility()
+{
+    if (!mMenu) return;
+    mMenu->setItemVisible("expand", TRUE);
+    mMenu->setItemVisible("collapse", TRUE);
+    mMenu->setItemVisible("upload_foto", FALSE);
+    mMenu->setItemVisible("load_assets", TRUE);
+    LLOutfitListGearMenuBase::onUpdateItemsVisibility();
+}
+
 // EOF