Merge remote-tracking branch 'origin/main' into DRTVWR-600-maint-A

# Conflicts:
#	autobuild.xml
#	indra/cmake/CMakeLists.txt
#	indra/cmake/GoogleMock.cmake
#	indra/llaudio/llaudioengine_fmodstudio.cpp
#	indra/llaudio/llaudioengine_fmodstudio.h
#	indra/llaudio/lllistener_fmodstudio.cpp
#	indra/llaudio/lllistener_fmodstudio.h
#	indra/llaudio/llstreamingaudio_fmodstudio.cpp
#	indra/llaudio/llstreamingaudio_fmodstudio.h
#	indra/llcharacter/llmultigesture.cpp
#	indra/llcharacter/llmultigesture.h
#	indra/llimage/llimage.cpp
#	indra/llimage/llimagepng.cpp
#	indra/llimage/llimageworker.cpp
#	indra/llimage/tests/llimageworker_test.cpp
#	indra/llmessage/tests/llmockhttpclient.h
#	indra/llprimitive/llgltfmaterial.h
#	indra/llrender/llfontfreetype.cpp
#	indra/llui/llcombobox.cpp
#	indra/llui/llfolderview.cpp
#	indra/llui/llfolderviewmodel.h
#	indra/llui/lllineeditor.cpp
#	indra/llui/lllineeditor.h
#	indra/llui/lltextbase.cpp
#	indra/llui/lltextbase.h
#	indra/llui/lltexteditor.cpp
#	indra/llui/lltextvalidate.cpp
#	indra/llui/lltextvalidate.h
#	indra/llui/lluictrl.h
#	indra/llui/llview.cpp
#	indra/llwindow/llwindowmacosx.cpp
#	indra/newview/app_settings/settings.xml
#	indra/newview/llappearancemgr.cpp
#	indra/newview/llappearancemgr.h
#	indra/newview/llavatarpropertiesprocessor.cpp
#	indra/newview/llavatarpropertiesprocessor.h
#	indra/newview/llbreadcrumbview.cpp
#	indra/newview/llbreadcrumbview.h
#	indra/newview/llbreastmotion.cpp
#	indra/newview/llbreastmotion.h
#	indra/newview/llconversationmodel.h
#	indra/newview/lldensityctrl.cpp
#	indra/newview/lldensityctrl.h
#	indra/newview/llface.inl
#	indra/newview/llfloatereditsky.cpp
#	indra/newview/llfloatereditwater.cpp
#	indra/newview/llfloateremojipicker.h
#	indra/newview/llfloaterimsessiontab.cpp
#	indra/newview/llfloaterprofiletexture.cpp
#	indra/newview/llfloaterprofiletexture.h
#	indra/newview/llgesturemgr.cpp
#	indra/newview/llgesturemgr.h
#	indra/newview/llimpanel.cpp
#	indra/newview/llimpanel.h
#	indra/newview/llinventorybridge.cpp
#	indra/newview/llinventorybridge.h
#	indra/newview/llinventoryclipboard.cpp
#	indra/newview/llinventoryclipboard.h
#	indra/newview/llinventoryfunctions.cpp
#	indra/newview/llinventoryfunctions.h
#	indra/newview/llinventorygallery.cpp
#	indra/newview/lllistbrowser.cpp
#	indra/newview/lllistbrowser.h
#	indra/newview/llpanelobjectinventory.cpp
#	indra/newview/llpanelprofile.cpp
#	indra/newview/llpanelprofile.h
#	indra/newview/llpreviewgesture.cpp
#	indra/newview/llsavedsettingsglue.cpp
#	indra/newview/llsavedsettingsglue.h
#	indra/newview/lltooldraganddrop.cpp
#	indra/newview/llurllineeditorctrl.cpp
#	indra/newview/llvectorperfoptions.cpp
#	indra/newview/llvectorperfoptions.h
#	indra/newview/llviewerparceloverlay.cpp
#	indra/newview/llviewertexlayer.cpp
#	indra/newview/llviewertexturelist.cpp
#	indra/newview/macmain.h
#	indra/test/test.cpp

1 files changed, 1149 insertions, 1149 deletions

diff --git a/indra/newview/llwearableitemslist.cpp b/indra/newview/llwearableitemslist.cpp
index bd27b75088..0c02076766 100644
--- a/indra/newview/llwearableitemslist.cpp
+++ b/indra/newview/llwearableitemslist.cpp
@@ -1,1149 +1,1149 @@
-/**
- * @file llwearableitemslist.cpp
- * @brief A flat list of wearable items.
- *
- * $LicenseInfo:firstyear=2010&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$
- */
-
-#include "llviewerprecompiledheaders.h"
-
-#include "llwearableitemslist.h"
-
-#include "lliconctrl.h"
-#include "llmenugl.h" // for LLContextMenu
-
-#include "llagentwearables.h"
-#include "llappearancemgr.h"
-#include "llinventoryfunctions.h"
-#include "llinventoryicon.h"
-#include "llgesturemgr.h"
-#include "lltransutil.h"
-#include "llviewerattachmenu.h"
-#include "llviewermenu.h"
-#include "llvoavatarself.h"
-
-class LLFindOutfitItems : public LLInventoryCollectFunctor
-{
-public:
-	LLFindOutfitItems() {}
-	virtual ~LLFindOutfitItems() {}
-	virtual bool operator()(LLInventoryCategory* cat,
-							LLInventoryItem* item);
-};
-
-bool LLFindOutfitItems::operator()(LLInventoryCategory* cat,
-								   LLInventoryItem* item)
-{
-	if(item)
-	{
-		if((item->getType() == LLAssetType::AT_CLOTHING)
-		   || (item->getType() == LLAssetType::AT_BODYPART)
-		   || (item->getType() == LLAssetType::AT_OBJECT)
-		   || (item->getType() == LLAssetType::AT_GESTURE))
-		{
-			return true;
-		}
-	}
-	return false;
-}
-
-//////////////////////////////////////////////////////////////////////////
-//////////////////////////////////////////////////////////////////////////
-//////////////////////////////////////////////////////////////////////////
-
-void LLPanelWearableListItem::onMouseEnter(S32 x, S32 y, MASK mask)
-{
-	LLPanelInventoryListItemBase::onMouseEnter(x, y, mask);
-	setWidgetsVisible(true);
-	reshapeWidgets();
-}
-
-void LLPanelWearableListItem::onMouseLeave(S32 x, S32 y, MASK mask)
-{
-	LLPanelInventoryListItemBase::onMouseLeave(x, y, mask);
-	setWidgetsVisible(false);
-	reshapeWidgets();
-}
-
-LLPanelWearableListItem::LLPanelWearableListItem(LLViewerInventoryItem* item, const LLPanelWearableListItem::Params& params)
-: LLPanelInventoryListItemBase(item, params)
-{
-}
-
-//////////////////////////////////////////////////////////////////////////
-//////////////////////////////////////////////////////////////////////////
-//////////////////////////////////////////////////////////////////////////
-static LLWidgetNameRegistry::StaticRegistrar sRegisterPanelWearableOutfitItem(&typeid(LLPanelWearableOutfitItem::Params), "wearable_outfit_list_item");
-
-LLPanelWearableOutfitItem::Params::Params()
-:   add_btn("add_btn"),
-    remove_btn("remove_btn")
-{
-}
-
-bool LLPanelWearableOutfitItem::postBuild()
-{
-    LLPanelWearableListItem::postBuild();
-    
-    if(mShowWidgets)
-    {
-        addWidgetToRightSide("add_wearable");
-        addWidgetToRightSide("remove_wearable");
-
-        childSetAction("add_wearable", boost::bind(&LLPanelWearableOutfitItem::onAddWearable, this));
-        childSetAction("remove_wearable", boost::bind(&LLPanelWearableOutfitItem::onRemoveWearable, this));
-
-        setWidgetsVisible(false);
-        reshapeWidgets();
-    }
-    return true;
-}
-
-bool LLPanelWearableOutfitItem::handleDoubleClick(S32 x, S32 y, MASK mask)
-{
-    if(!mShowWidgets)
-    {
-        return LLPanelWearableListItem::handleDoubleClick(x, y, mask);
-    }
-
-    if(LLAppearanceMgr::instance().isLinkedInCOF(mInventoryItemUUID))
-    {
-        onRemoveWearable();
-    }
-    else
-    {
-        onAddWearable();
-    }
-    return true;
-}
-
-void LLPanelWearableOutfitItem::onAddWearable()
-{
-    setWidgetsVisible(false);
-    reshapeWidgets();
-    LLAppearanceMgr::instance().wearItemOnAvatar(mInventoryItemUUID, true, false);
-}
-
-void LLPanelWearableOutfitItem::onRemoveWearable()
-{
-    setWidgetsVisible(false);
-    reshapeWidgets();
-    LLAppearanceMgr::instance().removeItemFromAvatar(mInventoryItemUUID);
-}
-
-// static
-LLPanelWearableOutfitItem* LLPanelWearableOutfitItem::create(LLViewerInventoryItem* item,
-															 bool worn_indication_enabled,
-                                                             bool show_widgets)
-{
-	LLPanelWearableOutfitItem* list_item = NULL;
-	if (item)
-	{
-		const LLPanelWearableOutfitItem::Params& params = LLUICtrlFactory::getDefaultParams<LLPanelWearableOutfitItem>();
-
-		list_item = new LLPanelWearableOutfitItem(item, worn_indication_enabled, params, show_widgets);
-		list_item->initFromParams(params);
-		list_item->postBuild();
-	}
-	return list_item;
-}
-
-LLPanelWearableOutfitItem::LLPanelWearableOutfitItem(LLViewerInventoryItem* item,
-                                                     bool worn_indication_enabled,
-                                                     const LLPanelWearableOutfitItem::Params& params,
-                                                     bool show_widgets)
-: LLPanelWearableListItem(item, params)
-, mWornIndicationEnabled(worn_indication_enabled)
-, mShowWidgets(show_widgets)
-{
-    if(mShowWidgets)
-    {
-        LLButton::Params button_params = params.add_btn;
-        applyXUILayout(button_params, this);
-        addChild(LLUICtrlFactory::create<LLButton>(button_params));
-
-        button_params = params.remove_btn;
-        applyXUILayout(button_params, this);
-        addChild(LLUICtrlFactory::create<LLButton>(button_params));
-    }
-}
-
-// virtual
-void LLPanelWearableOutfitItem::updateItem(const std::string& name,
-										   EItemState item_state)
-{
-	std::string search_label = name;
-
-	// Updating item's worn status depending on whether it is linked in COF or not.
-	// We don't use get_is_item_worn() here because this update is triggered by
-	// an inventory observer upon link in COF beind added or removed so actual
-	// worn status of a linked item may still remain unchanged.
-    bool is_worn = LLAppearanceMgr::instance().isLinkedInCOF(mInventoryItemUUID);
-	if (mWornIndicationEnabled && is_worn)
-	{
-		search_label += LLTrans::getString("worn");
-		item_state = IS_WORN;
-	}
-    if(mShowWidgets)
-    {
-        setShowWidget("add_wearable", !is_worn);
-
-        // Body parts can't be removed, only replaced
-        LLViewerInventoryItem* inv_item = getItem();
-        bool show_remove = is_worn && inv_item && (inv_item->getType() != LLAssetType::AT_BODYPART);
-        setShowWidget("remove_wearable", show_remove);
-
-        if(mHovered)
-        {
-            setWidgetsVisible(true);
-            reshapeWidgets();
-        }
-    }
-
-	LLPanelInventoryListItemBase::updateItem(search_label, item_state);
-}
-
-//////////////////////////////////////////////////////////////////////////
-//////////////////////////////////////////////////////////////////////////
-//////////////////////////////////////////////////////////////////////////
-static LLWidgetNameRegistry::StaticRegistrar sRegisterPanelClothingListItem(&typeid(LLPanelClothingListItem::Params), "clothing_list_item");
-
-
-LLPanelClothingListItem::Params::Params()
-:	up_btn("up_btn"),
-	down_btn("down_btn"),
-	edit_btn("edit_btn"),
-	lock_panel("lock_panel"),
-	edit_panel("edit_panel"),
-	lock_icon("lock_icon")
-{}
-
-// static
-LLPanelClothingListItem* LLPanelClothingListItem::create(LLViewerInventoryItem* item)
-{
-	LLPanelClothingListItem* list_item = NULL;
-	if(item)
-	{
-		const LLPanelClothingListItem::Params& params = LLUICtrlFactory::getDefaultParams<LLPanelClothingListItem>();
-		list_item = new LLPanelClothingListItem(item, params);
-		list_item->initFromParams(params);
-		list_item->postBuild();
-	}
-	return list_item;
-}
-
-LLPanelClothingListItem::LLPanelClothingListItem(LLViewerInventoryItem* item, const LLPanelClothingListItem::Params& params)
- : LLPanelDeletableWearableListItem(item, params)
-{
-	LLButton::Params button_params = params.up_btn;
-	applyXUILayout(button_params, this);
-	addChild(LLUICtrlFactory::create<LLButton>(button_params));
-
-	button_params = params.down_btn;
-	applyXUILayout(button_params, this);
-	addChild(LLUICtrlFactory::create<LLButton>(button_params));
-
-	LLPanel::Params panel_params = params.lock_panel;
-	applyXUILayout(panel_params, this);
-	LLPanel* lock_panelp = LLUICtrlFactory::create<LLPanel>(panel_params);
-	addChild(lock_panelp);
-
-	panel_params = params.edit_panel;
-	applyXUILayout(panel_params, this);
-	LLPanel* edit_panelp = LLUICtrlFactory::create<LLPanel>(panel_params);
-	addChild(edit_panelp);
-
-	if (lock_panelp)
-{
-		LLIconCtrl::Params icon_params = params.lock_icon;
-		applyXUILayout(icon_params, this);
-		lock_panelp->addChild(LLUICtrlFactory::create<LLIconCtrl>(icon_params));
-}
-
-	if (edit_panelp)
-{
-		button_params = params.edit_btn;
-		applyXUILayout(button_params, this);
-		edit_panelp->addChild(LLUICtrlFactory::create<LLButton>(button_params));
-	}
-
-	setSeparatorVisible(false);
-}
-
-LLPanelClothingListItem::~LLPanelClothingListItem()
-{
-}
-
-bool LLPanelClothingListItem::postBuild()
-{
-	LLPanelDeletableWearableListItem::postBuild();
-
-	addWidgetToRightSide("btn_move_up");
-	addWidgetToRightSide("btn_move_down");
-	addWidgetToRightSide("btn_lock");
-	addWidgetToRightSide("btn_edit_panel");
-
-	setWidgetsVisible(false);
-	reshapeWidgets();
-
-	return true;
-}
-
-//////////////////////////////////////////////////////////////////////////
-//////////////////////////////////////////////////////////////////////////
-//////////////////////////////////////////////////////////////////////////
-
-static LLWidgetNameRegistry::StaticRegistrar sRegisterPanelBodyPartsListItem(&typeid(LLPanelBodyPartsListItem::Params), "bodyparts_list_item");
-
-
-LLPanelBodyPartsListItem::Params::Params()
-:	edit_btn("edit_btn"),
-	edit_panel("edit_panel"),
-	lock_panel("lock_panel"),
-	lock_icon("lock_icon")
-{}
-
-// static
-LLPanelBodyPartsListItem* LLPanelBodyPartsListItem::create(LLViewerInventoryItem* item)
-{
-	LLPanelBodyPartsListItem* list_item = NULL;
-	if(item)
-	{
-		const Params& params = LLUICtrlFactory::getDefaultParams<LLPanelBodyPartsListItem>();
-		list_item = new LLPanelBodyPartsListItem(item, params);
-		list_item->initFromParams(params);
-		list_item->postBuild();
-	}
-	return list_item;
-}
-
-LLPanelBodyPartsListItem::LLPanelBodyPartsListItem(LLViewerInventoryItem* item, const LLPanelBodyPartsListItem::Params& params)
-: LLPanelWearableListItem(item, params)
-{
-	LLPanel::Params panel_params = params.edit_panel;
-	applyXUILayout(panel_params, this);
-	LLPanel* edit_panelp = LLUICtrlFactory::create<LLPanel>(panel_params);
-	addChild(edit_panelp);
-
-	panel_params = params.lock_panel;
-	applyXUILayout(panel_params, this);
-	LLPanel* lock_panelp = LLUICtrlFactory::create<LLPanel>(panel_params);
-	addChild(lock_panelp);
-	
-	if (edit_panelp)
-	{
-		LLButton::Params btn_params = params.edit_btn;
-		applyXUILayout(btn_params, this);
-		edit_panelp->addChild(LLUICtrlFactory::create<LLButton>(btn_params));
-}
-
-	if (lock_panelp)
-{
-		LLIconCtrl::Params icon_params = params.lock_icon;
-		applyXUILayout(icon_params, this);
-		lock_panelp->addChild(LLUICtrlFactory::create<LLIconCtrl>(icon_params));
-	}
-
-	setSeparatorVisible(true);
-}
-
-LLPanelBodyPartsListItem::~LLPanelBodyPartsListItem()
-{
-}
-
-bool LLPanelBodyPartsListItem::postBuild()
-{
-	LLPanelInventoryListItemBase::postBuild();
-
-	addWidgetToRightSide("btn_lock");
-	addWidgetToRightSide("btn_edit_panel");
-
-	setWidgetsVisible(false);
-	reshapeWidgets();
-
-	return true;
-}
-
-static LLWidgetNameRegistry::StaticRegistrar sRegisterPanelDeletableWearableListItem(&typeid(LLPanelDeletableWearableListItem::Params), "deletable_wearable_list_item");
-
-LLPanelDeletableWearableListItem::Params::Params()
-:	delete_btn("delete_btn")
-{}
-
-// static
-LLPanelDeletableWearableListItem* LLPanelDeletableWearableListItem::create(LLViewerInventoryItem* item)
-{
-	LLPanelDeletableWearableListItem* list_item = NULL;
-	if(item)
-	{
-		const Params& params = LLUICtrlFactory::getDefaultParams<LLPanelDeletableWearableListItem>();
-		list_item = new LLPanelDeletableWearableListItem(item, params);
-		list_item->initFromParams(params);
-		list_item->postBuild();
-	}
-	return list_item;
-}
-
-LLPanelDeletableWearableListItem::LLPanelDeletableWearableListItem(LLViewerInventoryItem* item, const LLPanelDeletableWearableListItem::Params& params)
-: LLPanelWearableListItem(item, params)
-{
-	LLButton::Params button_params = params.delete_btn;
-	applyXUILayout(button_params, this);
-	addChild(LLUICtrlFactory::create<LLButton>(button_params));
-
-	setSeparatorVisible(true);
-}
-
-bool LLPanelDeletableWearableListItem::postBuild()
-{
-	LLPanelWearableListItem::postBuild();
-
-	addWidgetToLeftSide("btn_delete");
-
-	LLButton* delete_btn = getChild<LLButton>("btn_delete");
-	// Reserve space for 'delete' button event if it is invisible.
-	setLeftWidgetsWidth(delete_btn->getRect().mRight);
-
-	setWidgetsVisible(false);
-	reshapeWidgets();
-
-	return true;
-}
-
-
-// static
-LLPanelAttachmentListItem* LLPanelAttachmentListItem::create(LLViewerInventoryItem* item)
-{
-	LLPanelAttachmentListItem* list_item = NULL;
-	if(item)
-	{
-		const Params& params = LLUICtrlFactory::getDefaultParams<LLPanelDeletableWearableListItem>();
-
-		list_item = new LLPanelAttachmentListItem(item, params);
-		list_item->initFromParams(params);
-		list_item->postBuild();
-	}
-	return list_item;
-}
-
-void LLPanelAttachmentListItem::updateItem(const std::string& name,
-										   EItemState item_state)
-{
-	std::string title_joint = name;
-
-	LLViewerInventoryItem* inv_item = getItem();
-	if (inv_item && isAgentAvatarValid() && gAgentAvatarp->isWearingAttachment(inv_item->getLinkedUUID()))
-	{
-		std::string found_name;
-		bool found = gAgentAvatarp->getAttachedPointName(inv_item->getLinkedUUID(),found_name);
-		std::string trans_name = LLTrans::getString(found_name);
-		if (!found)
-		{
-			LL_WARNS() << "invalid attachment joint, err " << found_name << LL_ENDL;
-		}
-		title_joint =  title_joint + " (" + trans_name + ")";
-	}
-
-	LLPanelInventoryListItemBase::updateItem(title_joint, item_state);
-}
-
-//////////////////////////////////////////////////////////////////////////
-//////////////////////////////////////////////////////////////////////////
-//////////////////////////////////////////////////////////////////////////
-static LLWidgetNameRegistry::StaticRegistrar sRegisterPanelDummyClothingListItem(&typeid(LLPanelDummyClothingListItem::Params), "dummy_clothing_list_item");
-
-LLPanelDummyClothingListItem::Params::Params()
-:	add_panel("add_panel"),
-	add_btn("add_btn")
-{}
-
-LLPanelDummyClothingListItem* LLPanelDummyClothingListItem::create(LLWearableType::EType w_type)
-{
-	const Params& params = LLUICtrlFactory::getDefaultParams<LLPanelDummyClothingListItem>();
-
-	LLPanelDummyClothingListItem* list_item = new LLPanelDummyClothingListItem(w_type, params);
-	list_item->initFromParams(params);
-	list_item->postBuild();
-	return list_item;
-}
-
-bool LLPanelDummyClothingListItem::postBuild()
-{
-	addWidgetToRightSide("btn_add_panel");
-
-	setIconImage(LLInventoryIcon::getIcon(LLAssetType::AT_CLOTHING, LLInventoryType::IT_NONE, mWearableType, false));
-	updateItem(wearableTypeToString(mWearableType));
-
-	// Make it look loke clothing item - reserve space for 'delete' button
-	setLeftWidgetsWidth(getChildView("item_icon")->getRect().mLeft);
-
-	setWidgetsVisible(false);
-	reshapeWidgets();
-
-	return true;
-}
-
-LLWearableType::EType LLPanelDummyClothingListItem::getWearableType() const
-{
-	return mWearableType;
-}
-
-LLPanelDummyClothingListItem::LLPanelDummyClothingListItem(LLWearableType::EType w_type, const LLPanelDummyClothingListItem::Params& params)
-:	LLPanelWearableListItem(NULL, params), 
-	mWearableType(w_type)
-{
-	LLPanel::Params panel_params(params.add_panel);
-	applyXUILayout(panel_params, this);
-	LLPanel* add_panelp = LLUICtrlFactory::create<LLPanel>(panel_params);
-	addChild(add_panelp);
-
-	if (add_panelp)
-{
-		LLButton::Params button_params(params.add_btn);
-		applyXUILayout(button_params, this);
-		add_panelp->addChild(LLUICtrlFactory::create<LLButton>(button_params));
-}
-
-	setSeparatorVisible(true);
-}
-
-typedef std::map<LLWearableType::EType, std::string> clothing_to_string_map_t;
-
-clothing_to_string_map_t init_clothing_string_map()
-{
-	clothing_to_string_map_t w_map;
-	w_map.insert(std::make_pair(LLWearableType::WT_SHIRT, "shirt_not_worn"));
-	w_map.insert(std::make_pair(LLWearableType::WT_PANTS, "pants_not_worn"));
-	w_map.insert(std::make_pair(LLWearableType::WT_SHOES, "shoes_not_worn"));
-	w_map.insert(std::make_pair(LLWearableType::WT_SOCKS, "socks_not_worn"));
-	w_map.insert(std::make_pair(LLWearableType::WT_JACKET, "jacket_not_worn"));
-	w_map.insert(std::make_pair(LLWearableType::WT_GLOVES, "gloves_not_worn"));
-	w_map.insert(std::make_pair(LLWearableType::WT_UNDERSHIRT, "undershirt_not_worn"));
-	w_map.insert(std::make_pair(LLWearableType::WT_UNDERPANTS, "underpants_not_worn"));
-	w_map.insert(std::make_pair(LLWearableType::WT_SKIRT, "skirt_not_worn"));
-	w_map.insert(std::make_pair(LLWearableType::WT_ALPHA, "alpha_not_worn"));
-	w_map.insert(std::make_pair(LLWearableType::WT_TATTOO, "tattoo_not_worn"));
-	w_map.insert(std::make_pair(LLWearableType::WT_UNIVERSAL, "universal_not_worn"));
-	w_map.insert(std::make_pair(LLWearableType::WT_PHYSICS, "physics_not_worn"));
-	return w_map;
-}
-
-std::string LLPanelDummyClothingListItem::wearableTypeToString(LLWearableType::EType w_type)
-{
-	static const clothing_to_string_map_t w_map = init_clothing_string_map();
-	static const std::string invalid_str = LLTrans::getString("invalid_not_worn");
-	
-	std::string type_str = invalid_str;
-	clothing_to_string_map_t::const_iterator it = w_map.find(w_type);
-	if(w_map.end() != it)
-	{
-		type_str = LLTrans::getString(it->second);
-	}
-	return type_str;
-}
-
-//////////////////////////////////////////////////////////////////////////
-//////////////////////////////////////////////////////////////////////////
-//////////////////////////////////////////////////////////////////////////
-
-LLWearableItemTypeNameComparator::LLWearableTypeOrder::LLWearableTypeOrder(LLWearableItemTypeNameComparator::ETypeListOrder order_priority, bool sort_asset_by_name, bool sort_wearable_by_name):
-		mOrderPriority(order_priority),
-		mSortAssetTypeByName(sort_asset_by_name),
-		mSortWearableTypeByName(sort_wearable_by_name)
-{
-}
-
-LLWearableItemTypeNameComparator::LLWearableItemTypeNameComparator()
-{
-	// By default the sort order conforms the order by spec of MY OUTFITS items list:
-	// 1. CLOTHING - sorted by name
-	// 2. OBJECT   - sorted by type
-	// 3. BODYPART - sorted by name
-	mWearableOrder[LLAssetType::AT_CLOTHING] = LLWearableTypeOrder(ORDER_RANK_1, false, false);
-	mWearableOrder[LLAssetType::AT_OBJECT]   = LLWearableTypeOrder(ORDER_RANK_2, true, true);
-	mWearableOrder[LLAssetType::AT_BODYPART] = LLWearableTypeOrder(ORDER_RANK_3, false, true);
-	mWearableOrder[LLAssetType::AT_GESTURE] = LLWearableTypeOrder(ORDER_RANK_4, true, false);
-}
-
-void LLWearableItemTypeNameComparator::setOrder(LLAssetType::EType items_of_type,  LLWearableItemTypeNameComparator::ETypeListOrder order_priority, bool sort_asset_items_by_name, bool sort_wearable_items_by_name)
-{
-	mWearableOrder[items_of_type] = LLWearableTypeOrder(order_priority, sort_asset_items_by_name, sort_wearable_items_by_name);
-}
-
-/*virtual*/
-bool LLWearableItemNameComparator::doCompare(const LLPanelInventoryListItemBase* wearable_item1, const LLPanelInventoryListItemBase* wearable_item2) const
-{
-	std::string name1 = wearable_item1->getItemName();
-	std::string name2 = wearable_item2->getItemName();
-
-	LLStringUtil::toUpper(name1);
-	LLStringUtil::toUpper(name2);
-
-	return name1 < name2;
-}
-
-/*virtual*/
-bool LLWearableItemTypeNameComparator::doCompare(const LLPanelInventoryListItemBase* wearable_item1, const LLPanelInventoryListItemBase* wearable_item2) const
-{
-	const LLAssetType::EType item_type1 = wearable_item1->getType();
-	const LLAssetType::EType item_type2 = wearable_item2->getType();
-
-	LLWearableItemTypeNameComparator::ETypeListOrder item_type_order1 = getTypeListOrder(item_type1);
-	LLWearableItemTypeNameComparator::ETypeListOrder item_type_order2 = getTypeListOrder(item_type2);
-
-	if (item_type_order1 != item_type_order2)
-	{
-		// If items are of different asset types we can compare them
-		// by types order in the list.
-		return item_type_order1 < item_type_order2;
-	}
-
-	if (sortAssetTypeByName(item_type1))
-	{
-		// If both items are of the same asset type except AT_CLOTHING and AT_BODYPART
-		// we can compare them by name.
-		return LLWearableItemNameComparator::doCompare(wearable_item1, wearable_item2);
-	}
-
-	const LLWearableType::EType item_wearable_type1 = wearable_item1->getWearableType();
-	const LLWearableType::EType item_wearable_type2 = wearable_item2->getWearableType();
-
-	if (item_wearable_type1 != item_wearable_type2)
-		// If items are of different LLWearableType::EType types they are compared
-		// by LLWearableType::EType. types order determined in LLWearableType::EType.
-	{
-		// If items are of different LLWearableType::EType types they are compared
-		// by LLWearableType::EType. types order determined in LLWearableType::EType.
-		return item_wearable_type1 < item_wearable_type2;
-	}
-	else
-	{
-		// If both items are of the same clothing type they are compared
-		// by description and place in reverse order (i.e. outer layer item
-		// on top) OR by name
-		if(sortWearableTypeByName(item_type1))
-		{
-			return LLWearableItemNameComparator::doCompare(wearable_item1, wearable_item2);
-		}
-		return wearable_item1->getDescription() > wearable_item2->getDescription();
-	}
-}
-
-LLWearableItemTypeNameComparator::ETypeListOrder LLWearableItemTypeNameComparator::getTypeListOrder(LLAssetType::EType item_type) const
-{
-	wearable_type_order_map_t::const_iterator const_it = mWearableOrder.find(item_type);
-
-
-	if(const_it == mWearableOrder.end())
-	{
-		LL_WARNS()<<"Absent information about order rang of items of "<<LLAssetType::getDesc(item_type)<<" type"<<LL_ENDL;
-		return ORDER_RANK_UNKNOWN;
-	}
-
-	return const_it->second.mOrderPriority;
-}
-
-bool LLWearableItemTypeNameComparator::sortAssetTypeByName(LLAssetType::EType item_type) const
-{
-	wearable_type_order_map_t::const_iterator const_it = mWearableOrder.find(item_type);
-
-
-	if(const_it == mWearableOrder.end())
-	{
-		LL_WARNS()<<"Absent information about sorting items of "<<LLAssetType::getDesc(item_type)<<" type"<<LL_ENDL;
-		return true;
-	}
-
-
-	return const_it->second.mSortAssetTypeByName;
-	}
-
-
-bool LLWearableItemTypeNameComparator::sortWearableTypeByName(LLAssetType::EType item_type) const
-{
-	wearable_type_order_map_t::const_iterator const_it = mWearableOrder.find(item_type);
-
-
-	if(const_it == mWearableOrder.end())
-	{
-		LL_WARNS()<<"Absent information about sorting items of "<<LLAssetType::getDesc(item_type)<<" type"<<LL_ENDL;
-		return true;
-}
-
-
-	return const_it->second.mSortWearableTypeByName;
-}
-
-/*virtual*/
-bool LLWearableItemCreationDateComparator::doCompare(const LLPanelInventoryListItemBase* item1, const LLPanelInventoryListItemBase* item2) const
-{
-	time_t date1 = item1->getCreationDate();
-	time_t date2 = item2->getCreationDate();
-
-	if (date1 == date2)
-	{
-		return LLWearableItemNameComparator::doCompare(item1, item2);
-	}
-
-	return date1 > date2;
-}
-//////////////////////////////////////////////////////////////////////////
-//////////////////////////////////////////////////////////////////////////
-//////////////////////////////////////////////////////////////////////////
-
-static LLWearableItemTypeNameComparator WEARABLE_TYPE_NAME_COMPARATOR;
-static const LLWearableItemTypeNameComparator WEARABLE_TYPE_LAYER_COMPARATOR;
-static const LLWearableItemNameComparator WEARABLE_NAME_COMPARATOR;
-static const LLWearableItemCreationDateComparator WEARABLE_CREATION_DATE_COMPARATOR;
-
-static const LLDefaultChildRegistry::Register<LLWearableItemsList> r("wearable_items_list");
-
-LLWearableItemsList::Params::Params()
-:	standalone("standalone", true)
-,	worn_indication_enabled("worn_indication_enabled", true)
-,   show_item_widgets("show_item_widgets", false)
-{}
-
-LLWearableItemsList::LLWearableItemsList(const LLWearableItemsList::Params& p)
-:	LLInventoryItemsList(p)
-{
-	setSortOrder(E_SORT_BY_TYPE_LAYER, false);
-	mMenuWearableType = LLWearableType::WT_NONE;
-	mIsStandalone = p.standalone;
-	if (mIsStandalone)
-	{
-		// Use built-in context menu.
-		setRightMouseDownCallback(boost::bind(&LLWearableItemsList::onRightClick, this, _2, _3));
-	}
-	mWornIndicationEnabled = p.worn_indication_enabled;
-	setNoItemsCommentText(LLTrans::getString("LoadingData"));
-    mShowItemWidgets = p.show_item_widgets;
-}
-
-// virtual
-LLWearableItemsList::~LLWearableItemsList()
-{}
-
-// virtual
-LLPanel* LLWearableItemsList::createNewItem(LLViewerInventoryItem* item)
-{
-    if (!item)
-    {
-        LL_WARNS() << "No inventory item. Couldn't create flat list item." << LL_ENDL;
-        llassert(item != NULL);
-        return NULL;
-    }
-
-    return LLPanelWearableOutfitItem::create(item, mWornIndicationEnabled, mShowItemWidgets);
-}
-
-void LLWearableItemsList::updateList(const LLUUID& category_id)
-{
-	LLInventoryModel::cat_array_t cat_array;
-	LLInventoryModel::item_array_t item_array;
-
-	LLFindOutfitItems collector = LLFindOutfitItems();
-	// collectDescendentsIf takes non-const reference:
-	gInventory.collectDescendentsIf(
-		category_id,
-		cat_array,
-		item_array,
-		LLInventoryModel::EXCLUDE_TRASH,
-		collector);
-
-	if(item_array.empty() && gInventory.isCategoryComplete(category_id))
-	{
-		setNoItemsCommentText(LLTrans::getString("EmptyOutfitText"));
-	}
-
-	refreshList(item_array);
-}
-
-void LLWearableItemsList::updateChangedItems(const uuid_vec_t& changed_items_uuids)
-{
-	// nothing to update
-	if (changed_items_uuids.empty())
-		return;
-
-	uuid_vec_t::const_iterator uuids_begin = changed_items_uuids.begin(), uuids_end = changed_items_uuids.end();
-	pairs_const_iterator_t pairs_iter = getItemPairs().begin(), pairs_end = getItemPairs().end();
-	while (pairs_iter != pairs_end)
-	{
-		LLPanel* panel = (*(pairs_iter++))->first;
-		LLPanelInventoryListItemBase* item = dynamic_cast<LLPanelInventoryListItemBase*>(panel);
-		if (!item)
-			continue;
-
-		LLViewerInventoryItem* inv_item = item->getItem();
-		if (!inv_item)
-			continue;
-
-        const LLUUID& linked_uuid = inv_item->getLinkedUUID();
-        if (std::find(uuids_begin, uuids_end, linked_uuid) != uuids_end)
-        {
-            item->setNeedsRefresh(true);
-        }
-	}
-}
-
-void LLWearableItemsList::onRightClick(S32 x, S32 y)
-{
-	uuid_vec_t selected_uuids;
-
-	getSelectedUUIDs(selected_uuids);
-	if (selected_uuids.empty())
-	{
-		if ((mMenuWearableType != LLWearableType::WT_NONE) && (size() == 0))
-		{
-			ContextMenu::instance().show(this, mMenuWearableType, x, y);
-		}
-	}
-	else
-	{
-		ContextMenu::instance().show(this, selected_uuids, x, y);
-	}
-}
-
-void LLWearableItemsList::setSortOrder(ESortOrder sort_order, bool sort_now)
-{
-	switch (sort_order)
-	{
-	case E_SORT_BY_MOST_RECENT:
-		setComparator(&WEARABLE_CREATION_DATE_COMPARATOR);
-		break;
-	case E_SORT_BY_NAME:
-		setComparator(&WEARABLE_NAME_COMPARATOR);
-		break;
-	case E_SORT_BY_TYPE_LAYER:
-		setComparator(&WEARABLE_TYPE_LAYER_COMPARATOR);
-		break;
-	case E_SORT_BY_TYPE_NAME:
-	{
-		WEARABLE_TYPE_NAME_COMPARATOR.setOrder(LLAssetType::AT_CLOTHING, LLWearableItemTypeNameComparator::ORDER_RANK_1, false, true);
-		setComparator(&WEARABLE_TYPE_NAME_COMPARATOR);
-		break;
-	}
-
-	// No "default:" to raise compiler warning
-	// if we're not handling something
-	}
-
-	mSortOrder = sort_order;
-
-	if (sort_now)
-	{
-		sort();
-	}
-}
-
-//////////////////////////////////////////////////////////////////////////
-/// ContextMenu
-//////////////////////////////////////////////////////////////////////////
-
-LLWearableItemsList::ContextMenu::ContextMenu()
-:	mParent(NULL)
-{
-}
-
-void LLWearableItemsList::ContextMenu::show(LLView* spawning_view, const uuid_vec_t& uuids, S32 x, S32 y)
-{
-	mParent = dynamic_cast<LLWearableItemsList*>(spawning_view);
-	LLListContextMenu::show(spawning_view, uuids, x, y);
-	mParent = NULL; // to avoid dereferencing an invalid pointer
-}
-
-void LLWearableItemsList::ContextMenu::show(LLView* spawning_view, LLWearableType::EType w_type, S32 x, S32 y)
-{
-	mParent = dynamic_cast<LLWearableItemsList*>(spawning_view);
-	LLContextMenu* menup = mMenuHandle.get();
-	if (menup)
-	{
-		//preventing parent (menu holder) from deleting already "dead" context menus on exit
-		LLView* parent = menup->getParent();
-		if (parent)
-		{
-			parent->removeChild(menup);
-		}
-		delete menup;
-		mUUIDs.clear();
-	}
-
-	LLUICtrl::CommitCallbackRegistry::ScopedRegistrar registrar;
-    registrar.add("Wearable.CreateNew", boost::bind(createNewWearableByType, w_type));
-	menup = createFromFile("menu_wearable_list_item.xml");
-	if (!menup)
-	{
-		LL_WARNS() << "Context menu creation failed" << LL_ENDL;
-		return;
-	}
-	setMenuItemVisible(menup, "create_new", true);
-	setMenuItemEnabled(menup, "create_new", true);
-	setMenuItemVisible(menup, "wearable_attach_to", false);
-	setMenuItemVisible(menup, "wearable_attach_to_hud", false);
-
-	std::string new_label = LLTrans::getString("create_new_" + LLWearableType::getInstance()->getTypeName(w_type));
-	LLMenuItemGL* menu_item = menup->getChild<LLMenuItemGL>("create_new");
-	menu_item->setLabel(new_label);
-
-	mMenuHandle = menup->getHandle();
-	menup->show(x, y);
-	LLMenuGL::showPopup(spawning_view, menup, x, y);
-
-	mParent = NULL; // to avoid dereferencing an invalid pointer
-}
-
-// virtual
-LLContextMenu* LLWearableItemsList::ContextMenu::createMenu()
-{
-	LLUICtrl::CommitCallbackRegistry::ScopedRegistrar registrar;
-	const uuid_vec_t& ids = mUUIDs;		// selected items IDs
-	LLUUID selected_id = ids.front();	// ID of the first selected item
-
-	// Register handlers common for all wearable types.
-	registrar.add("Wearable.Wear", boost::bind(wear_multiple, ids, true));
-	registrar.add("Wearable.Add", boost::bind(wear_multiple, ids, false));
-	registrar.add("Wearable.Edit", boost::bind(handle_item_edit, selected_id));
-	registrar.add("Wearable.CreateNew", boost::bind(createNewWearable, selected_id));
-	registrar.add("Wearable.ShowOriginal", boost::bind(show_item_original, selected_id));
-	registrar.add("Wearable.TakeOffDetach", 
-				  boost::bind(&LLAppearanceMgr::removeItemsFromAvatar, LLAppearanceMgr::getInstance(), ids));
-
-	// Register handlers for clothing.
-	registrar.add("Clothing.TakeOff", 
-				  boost::bind(&LLAppearanceMgr::removeItemsFromAvatar, LLAppearanceMgr::getInstance(), ids));
-
-	// Register handlers for body parts.
-
-	// Register handlers for attachments.
-	registrar.add("Attachment.Detach", 
-				  boost::bind(&LLAppearanceMgr::removeItemsFromAvatar, LLAppearanceMgr::getInstance(), ids));
-	registrar.add("Attachment.Touch", boost::bind(handle_attachment_touch, selected_id));
-	registrar.add("Attachment.Profile", boost::bind(show_item_profile, selected_id));
-	registrar.add("Object.Attach", boost::bind(LLViewerAttachMenu::attachObjects, ids, _2));
-
-	// Create the menu.
-	LLContextMenu* menu = createFromFile("menu_wearable_list_item.xml");
-
-	// Determine which items should be visible/enabled.
-	updateItemsVisibility(menu);
-
-	// Update labels for the items requiring that.
-	updateItemsLabels(menu);
-	return menu;
-}
-
-void LLWearableItemsList::ContextMenu::updateItemsVisibility(LLContextMenu* menu)
-{
-	if (!menu)
-	{
-		LL_WARNS() << "Invalid menu" << LL_ENDL;
-		return;
-	}
-
-	const uuid_vec_t& ids = mUUIDs;	// selected items IDs
-	U32 mask = 0;					// mask of selected items' types
-	U32 n_items = ids.size();		// number of selected items
-	U32 n_worn = 0;					// number of worn items among the selected ones
-	U32 n_already_worn = 0;			// number of items worn of same type as selected items
-	U32 n_links = 0;				// number of links among the selected items
-	U32 n_editable = 0;				// number of editable items among the selected ones
-	U32 n_touchable = 0;            // number of touchable items among the selected ones
-
-	bool can_be_worn = true;
-
-	for (uuid_vec_t::const_iterator it = ids.begin(); it != ids.end(); ++it)
-	{
-		LLUUID id = *it;
-		LLViewerInventoryItem* item = gInventory.getItem(id);
-
-		if (!item)
-		{
-			LL_WARNS() << "Invalid item" << LL_ENDL;
-			// *NOTE: the logic below may not work in this case
-			continue;
-		}
-
-		updateMask(mask, item->getType());
-
-		const LLWearableType::EType wearable_type = item->getWearableType();
-		const bool is_link = item->getIsLinkType();
-		const bool is_worn = get_is_item_worn(id);
-		const bool is_editable = get_is_item_editable(id);
-		const bool is_touchable = enable_attachment_touch(id);
-		const bool is_already_worn = gAgentWearables.selfHasWearable(wearable_type);
-		if (is_worn)
-		{
-			++n_worn;
-		}
-		if (is_touchable)
-		{
-			++n_touchable;
-		}
-		if (is_editable)
-		{
-			++n_editable;
-		}
-		if (is_link)
-		{
-			++n_links;
-		}
-		if (is_already_worn)
-		{
-			++n_already_worn;
-		}
-
-		if (can_be_worn)
-		{
-			can_be_worn = get_can_item_be_worn(item->getLinkedUUID());
-		}
-	} // for
-
-	bool standalone = mParent ? mParent->isStandalone() : false;
-	bool wear_add_visible = mask & (MASK_CLOTHING|MASK_ATTACHMENT) && n_worn == 0 && can_be_worn && (n_already_worn != 0 || mask & MASK_ATTACHMENT);
-
-	// *TODO: eliminate multiple traversals over the menu items
-	setMenuItemVisible(menu, "wear_wear", 			n_already_worn == 0 && n_worn == 0 && can_be_worn);
-	setMenuItemEnabled(menu, "wear_wear", 			n_already_worn == 0 && n_worn == 0);
-	setMenuItemVisible(menu, "wear_add",			wear_add_visible);
-	setMenuItemEnabled(menu, "wear_add",			LLAppearanceMgr::instance().canAddWearables(ids));
-	setMenuItemVisible(menu, "wear_replace",		n_worn == 0 && n_already_worn != 0 && can_be_worn);
-	//visible only when one item selected and this item is worn
-	setMenuItemVisible(menu, "touch",				!standalone && mask == MASK_ATTACHMENT && n_worn == n_items);
-	setMenuItemEnabled(menu, "touch",				n_touchable && n_worn == 1 && n_items == 1);
-	setMenuItemVisible(menu, "edit",				!standalone && mask & (MASK_CLOTHING|MASK_BODYPART|MASK_ATTACHMENT) && n_worn == n_items);
-	setMenuItemEnabled(menu, "edit",				n_editable && n_worn == 1 && n_items == 1);
-	setMenuItemVisible(menu, "create_new",			mask & (MASK_CLOTHING|MASK_BODYPART) && n_items == 1);
-	setMenuItemEnabled(menu, "create_new",			LLAppearanceMgr::instance().canAddWearables(ids));
-	setMenuItemVisible(menu, "show_original",		!standalone);
-	setMenuItemEnabled(menu, "show_original",		n_items == 1 && n_links == n_items);
-	setMenuItemVisible(menu, "take_off",			mask == MASK_CLOTHING && n_worn == n_items);
-	setMenuItemVisible(menu, "detach",				mask == MASK_ATTACHMENT && n_worn == n_items);
-	setMenuItemVisible(menu, "take_off_or_detach",	mask == (MASK_ATTACHMENT|MASK_CLOTHING));
-	setMenuItemEnabled(menu, "take_off_or_detach",	n_worn == n_items);
-	setMenuItemVisible(menu, "object_profile",		!standalone);
-	setMenuItemEnabled(menu, "object_profile",		n_items == 1);
-	setMenuItemVisible(menu, "--no options--", 		false);
-	setMenuItemEnabled(menu, "--no options--",		false);
-
-	// Populate or hide the "Attach to..." / "Attach to HUD..." submenus.
-	if (mask == MASK_ATTACHMENT && n_worn == 0)
-	{
-		LLViewerAttachMenu::populateMenus("wearable_attach_to", "wearable_attach_to_hud");
-	}
-	else
-	{
-		setMenuItemVisible(menu, "wearable_attach_to",			false);
-		setMenuItemVisible(menu, "wearable_attach_to_hud",		false);
-	}
-
-	if (mask & MASK_UNKNOWN)
-	{
-		LL_WARNS() << "Non-wearable items passed." << LL_ENDL;
-	}
-
-	U32 num_visible_items = 0;
-	for (U32 menu_item_index = 0; menu_item_index < menu->getItemCount(); ++menu_item_index)
-	{
-		const LLMenuItemGL* menu_item = menu->getItem(menu_item_index);
-		if (menu_item && menu_item->getVisible())
-		{
-			num_visible_items++;
-		}
-	}
-	if (num_visible_items == 0)
-	{
-		setMenuItemVisible(menu, "--no options--", true);
-	}
-}
-
-void LLWearableItemsList::ContextMenu::updateItemsLabels(LLContextMenu* menu)
-{
-	llassert(menu);
-	if (!menu) return;
-
-	// Set proper label for the "Create new <WEARABLE_TYPE>" menu item.
-	LLViewerInventoryItem* item = gInventory.getLinkedItem(mUUIDs.back());
-	if (!item || !item->isWearableType()) return;
-
-	LLWearableType::EType w_type = item->getWearableType();
-	std::string new_label = LLTrans::getString("create_new_" + LLWearableType::getInstance()->getTypeName(w_type));
-
-	LLMenuItemGL* menu_item = menu->getChild<LLMenuItemGL>("create_new");
-	menu_item->setLabel(new_label);
-}
-
-// We need this method to convert non-zero bool values to exactly 1 (true).
-// Otherwise code relying on a bool value being true may fail
-// (I experienced a weird assert in LLView::drawChildren() because of that.
-// static
-void LLWearableItemsList::ContextMenu::setMenuItemVisible(LLContextMenu* menu, const std::string& name, bool val)
-{
-	menu->setItemVisible(name, val);
-}
-
-// static
-void LLWearableItemsList::ContextMenu::setMenuItemEnabled(LLContextMenu* menu, const std::string& name, bool val)
-{
-	menu->setItemEnabled(name, val);
-}
-
-// static
-void LLWearableItemsList::ContextMenu::updateMask(U32& mask, LLAssetType::EType at)
-{
-	if (at == LLAssetType::AT_CLOTHING)
-	{
-		mask |= MASK_CLOTHING;
-	}
-	else if (at == LLAssetType::AT_BODYPART)
-	{
-		mask |= MASK_BODYPART;
-	}
-	else if (at == LLAssetType::AT_OBJECT)
-	{
-		mask |= MASK_ATTACHMENT;
-	}
-	else if (at == LLAssetType::AT_GESTURE)
-	{
-		mask |= MASK_GESTURE;
-	}
-	else
-	{
-		mask |= MASK_UNKNOWN;
-	}
-}
-
-// static
-void LLWearableItemsList::ContextMenu::createNewWearable(const LLUUID& item_id)
-{
-	LLViewerInventoryItem* item = gInventory.getLinkedItem(item_id);
-	if (!item || !item->isWearableType()) return;
-
-	LLAgentWearables::createWearable(item->getWearableType(), true);
-}
-
-// static
-void LLWearableItemsList::ContextMenu::createNewWearableByType(LLWearableType::EType type)
-{
-	LLAgentWearables::createWearable(type, true);
-}
-
-// EOF
+/**

+ * @file llwearableitemslist.cpp

+ * @brief A flat list of wearable items.

+ *

+ * $LicenseInfo:firstyear=2010&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$

+ */

+

+#include "llviewerprecompiledheaders.h"

+

+#include "llwearableitemslist.h"

+

+#include "lliconctrl.h"

+#include "llmenugl.h" // for LLContextMenu

+

+#include "llagentwearables.h"

+#include "llappearancemgr.h"

+#include "llinventoryfunctions.h"

+#include "llinventoryicon.h"

+#include "llgesturemgr.h"

+#include "lltransutil.h"

+#include "llviewerattachmenu.h"

+#include "llviewermenu.h"

+#include "llvoavatarself.h"

+

+class LLFindOutfitItems : public LLInventoryCollectFunctor

+{

+public:

+    LLFindOutfitItems() {}

+    virtual ~LLFindOutfitItems() {}

+    virtual bool operator()(LLInventoryCategory* cat,

+                            LLInventoryItem* item);

+};

+

+bool LLFindOutfitItems::operator()(LLInventoryCategory* cat,

+                                   LLInventoryItem* item)

+{

+    if(item)

+    {

+        if((item->getType() == LLAssetType::AT_CLOTHING)

+           || (item->getType() == LLAssetType::AT_BODYPART)

+           || (item->getType() == LLAssetType::AT_OBJECT)

+           || (item->getType() == LLAssetType::AT_GESTURE))

+        {

+            return true;

+        }

+    }

+    return false;

+}

+

+//////////////////////////////////////////////////////////////////////////

+//////////////////////////////////////////////////////////////////////////

+//////////////////////////////////////////////////////////////////////////

+

+void LLPanelWearableListItem::onMouseEnter(S32 x, S32 y, MASK mask)

+{

+    LLPanelInventoryListItemBase::onMouseEnter(x, y, mask);

+    setWidgetsVisible(true);

+    reshapeWidgets();

+}

+

+void LLPanelWearableListItem::onMouseLeave(S32 x, S32 y, MASK mask)

+{

+    LLPanelInventoryListItemBase::onMouseLeave(x, y, mask);

+    setWidgetsVisible(false);

+    reshapeWidgets();

+}

+

+LLPanelWearableListItem::LLPanelWearableListItem(LLViewerInventoryItem* item, const LLPanelWearableListItem::Params& params)

+: LLPanelInventoryListItemBase(item, params)

+{

+}

+

+//////////////////////////////////////////////////////////////////////////

+//////////////////////////////////////////////////////////////////////////

+//////////////////////////////////////////////////////////////////////////

+static LLWidgetNameRegistry::StaticRegistrar sRegisterPanelWearableOutfitItem(&typeid(LLPanelWearableOutfitItem::Params), "wearable_outfit_list_item");

+

+LLPanelWearableOutfitItem::Params::Params()

+:   add_btn("add_btn"),

+    remove_btn("remove_btn")

+{

+}

+

+bool LLPanelWearableOutfitItem::postBuild()

+{

+    LLPanelWearableListItem::postBuild();

+

+    if(mShowWidgets)

+    {

+        addWidgetToRightSide("add_wearable");

+        addWidgetToRightSide("remove_wearable");

+

+        childSetAction("add_wearable", boost::bind(&LLPanelWearableOutfitItem::onAddWearable, this));

+        childSetAction("remove_wearable", boost::bind(&LLPanelWearableOutfitItem::onRemoveWearable, this));

+

+        setWidgetsVisible(false);

+        reshapeWidgets();

+    }

+    return true;

+}

+

+bool LLPanelWearableOutfitItem::handleDoubleClick(S32 x, S32 y, MASK mask)

+{

+    if(!mShowWidgets)

+    {

+        return LLPanelWearableListItem::handleDoubleClick(x, y, mask);

+    }

+

+    if(LLAppearanceMgr::instance().isLinkedInCOF(mInventoryItemUUID))

+    {

+        onRemoveWearable();

+    }

+    else

+    {

+        onAddWearable();

+    }

+    return true;

+}

+

+void LLPanelWearableOutfitItem::onAddWearable()

+{

+    setWidgetsVisible(false);

+    reshapeWidgets();

+    LLAppearanceMgr::instance().wearItemOnAvatar(mInventoryItemUUID, true, false);

+}

+

+void LLPanelWearableOutfitItem::onRemoveWearable()

+{

+    setWidgetsVisible(false);

+    reshapeWidgets();

+    LLAppearanceMgr::instance().removeItemFromAvatar(mInventoryItemUUID);

+}

+

+// static

+LLPanelWearableOutfitItem* LLPanelWearableOutfitItem::create(LLViewerInventoryItem* item,

+                                                             bool worn_indication_enabled,

+                                                             bool show_widgets)

+{

+    LLPanelWearableOutfitItem* list_item = NULL;

+    if (item)

+    {

+        const LLPanelWearableOutfitItem::Params& params = LLUICtrlFactory::getDefaultParams<LLPanelWearableOutfitItem>();

+

+        list_item = new LLPanelWearableOutfitItem(item, worn_indication_enabled, params, show_widgets);

+        list_item->initFromParams(params);

+        list_item->postBuild();

+    }

+    return list_item;

+}

+

+LLPanelWearableOutfitItem::LLPanelWearableOutfitItem(LLViewerInventoryItem* item,

+                                                     bool worn_indication_enabled,

+                                                     const LLPanelWearableOutfitItem::Params& params,

+                                                     bool show_widgets)

+: LLPanelWearableListItem(item, params)

+, mWornIndicationEnabled(worn_indication_enabled)

+, mShowWidgets(show_widgets)

+{

+    if(mShowWidgets)

+    {

+        LLButton::Params button_params = params.add_btn;

+        applyXUILayout(button_params, this);

+        addChild(LLUICtrlFactory::create<LLButton>(button_params));

+

+        button_params = params.remove_btn;

+        applyXUILayout(button_params, this);

+        addChild(LLUICtrlFactory::create<LLButton>(button_params));

+    }

+}

+

+// virtual

+void LLPanelWearableOutfitItem::updateItem(const std::string& name,

+                                           EItemState item_state)

+{

+    std::string search_label = name;

+

+    // Updating item's worn status depending on whether it is linked in COF or not.

+    // We don't use get_is_item_worn() here because this update is triggered by

+    // an inventory observer upon link in COF beind added or removed so actual

+    // worn status of a linked item may still remain unchanged.

+    bool is_worn = LLAppearanceMgr::instance().isLinkedInCOF(mInventoryItemUUID);

+    if (mWornIndicationEnabled && is_worn)

+    {

+        search_label += LLTrans::getString("worn");

+        item_state = IS_WORN;

+    }

+    if(mShowWidgets)

+    {

+        setShowWidget("add_wearable", !is_worn);

+

+        // Body parts can't be removed, only replaced

+        LLViewerInventoryItem* inv_item = getItem();

+        bool show_remove = is_worn && inv_item && (inv_item->getType() != LLAssetType::AT_BODYPART);

+        setShowWidget("remove_wearable", show_remove);

+

+        if(mHovered)

+        {

+            setWidgetsVisible(true);

+            reshapeWidgets();

+        }

+    }

+

+    LLPanelInventoryListItemBase::updateItem(search_label, item_state);

+}

+

+//////////////////////////////////////////////////////////////////////////

+//////////////////////////////////////////////////////////////////////////

+//////////////////////////////////////////////////////////////////////////

+static LLWidgetNameRegistry::StaticRegistrar sRegisterPanelClothingListItem(&typeid(LLPanelClothingListItem::Params), "clothing_list_item");

+

+

+LLPanelClothingListItem::Params::Params()

+:   up_btn("up_btn"),

+    down_btn("down_btn"),

+    edit_btn("edit_btn"),

+    lock_panel("lock_panel"),

+    edit_panel("edit_panel"),

+    lock_icon("lock_icon")

+{}

+

+// static

+LLPanelClothingListItem* LLPanelClothingListItem::create(LLViewerInventoryItem* item)

+{

+    LLPanelClothingListItem* list_item = NULL;

+    if(item)

+    {

+        const LLPanelClothingListItem::Params& params = LLUICtrlFactory::getDefaultParams<LLPanelClothingListItem>();

+        list_item = new LLPanelClothingListItem(item, params);

+        list_item->initFromParams(params);

+        list_item->postBuild();

+    }

+    return list_item;

+}

+

+LLPanelClothingListItem::LLPanelClothingListItem(LLViewerInventoryItem* item, const LLPanelClothingListItem::Params& params)

+ : LLPanelDeletableWearableListItem(item, params)

+{

+    LLButton::Params button_params = params.up_btn;

+    applyXUILayout(button_params, this);

+    addChild(LLUICtrlFactory::create<LLButton>(button_params));

+

+    button_params = params.down_btn;

+    applyXUILayout(button_params, this);

+    addChild(LLUICtrlFactory::create<LLButton>(button_params));

+

+    LLPanel::Params panel_params = params.lock_panel;

+    applyXUILayout(panel_params, this);

+    LLPanel* lock_panelp = LLUICtrlFactory::create<LLPanel>(panel_params);

+    addChild(lock_panelp);

+

+    panel_params = params.edit_panel;

+    applyXUILayout(panel_params, this);

+    LLPanel* edit_panelp = LLUICtrlFactory::create<LLPanel>(panel_params);

+    addChild(edit_panelp);

+

+    if (lock_panelp)

+{

+        LLIconCtrl::Params icon_params = params.lock_icon;

+        applyXUILayout(icon_params, this);

+        lock_panelp->addChild(LLUICtrlFactory::create<LLIconCtrl>(icon_params));

+}

+

+    if (edit_panelp)

+{

+        button_params = params.edit_btn;

+        applyXUILayout(button_params, this);

+        edit_panelp->addChild(LLUICtrlFactory::create<LLButton>(button_params));

+    }

+

+    setSeparatorVisible(false);

+}

+

+LLPanelClothingListItem::~LLPanelClothingListItem()

+{

+}

+

+bool LLPanelClothingListItem::postBuild()

+{

+    LLPanelDeletableWearableListItem::postBuild();

+

+    addWidgetToRightSide("btn_move_up");

+    addWidgetToRightSide("btn_move_down");

+    addWidgetToRightSide("btn_lock");

+    addWidgetToRightSide("btn_edit_panel");

+

+    setWidgetsVisible(false);

+    reshapeWidgets();

+

+    return true;

+}

+

+//////////////////////////////////////////////////////////////////////////

+//////////////////////////////////////////////////////////////////////////

+//////////////////////////////////////////////////////////////////////////

+

+static LLWidgetNameRegistry::StaticRegistrar sRegisterPanelBodyPartsListItem(&typeid(LLPanelBodyPartsListItem::Params), "bodyparts_list_item");

+

+

+LLPanelBodyPartsListItem::Params::Params()

+:   edit_btn("edit_btn"),

+    edit_panel("edit_panel"),

+    lock_panel("lock_panel"),

+    lock_icon("lock_icon")

+{}

+

+// static

+LLPanelBodyPartsListItem* LLPanelBodyPartsListItem::create(LLViewerInventoryItem* item)

+{

+    LLPanelBodyPartsListItem* list_item = NULL;

+    if(item)

+    {

+        const Params& params = LLUICtrlFactory::getDefaultParams<LLPanelBodyPartsListItem>();

+        list_item = new LLPanelBodyPartsListItem(item, params);

+        list_item->initFromParams(params);

+        list_item->postBuild();

+    }

+    return list_item;

+}

+

+LLPanelBodyPartsListItem::LLPanelBodyPartsListItem(LLViewerInventoryItem* item, const LLPanelBodyPartsListItem::Params& params)

+: LLPanelWearableListItem(item, params)

+{

+    LLPanel::Params panel_params = params.edit_panel;

+    applyXUILayout(panel_params, this);

+    LLPanel* edit_panelp = LLUICtrlFactory::create<LLPanel>(panel_params);

+    addChild(edit_panelp);

+

+    panel_params = params.lock_panel;

+    applyXUILayout(panel_params, this);

+    LLPanel* lock_panelp = LLUICtrlFactory::create<LLPanel>(panel_params);

+    addChild(lock_panelp);

+

+    if (edit_panelp)

+    {

+        LLButton::Params btn_params = params.edit_btn;

+        applyXUILayout(btn_params, this);

+        edit_panelp->addChild(LLUICtrlFactory::create<LLButton>(btn_params));

+}

+

+    if (lock_panelp)

+{

+        LLIconCtrl::Params icon_params = params.lock_icon;

+        applyXUILayout(icon_params, this);

+        lock_panelp->addChild(LLUICtrlFactory::create<LLIconCtrl>(icon_params));

+    }

+

+    setSeparatorVisible(true);

+}

+

+LLPanelBodyPartsListItem::~LLPanelBodyPartsListItem()

+{

+}

+

+bool LLPanelBodyPartsListItem::postBuild()

+{

+    LLPanelInventoryListItemBase::postBuild();

+

+    addWidgetToRightSide("btn_lock");

+    addWidgetToRightSide("btn_edit_panel");

+

+    setWidgetsVisible(false);

+    reshapeWidgets();

+

+    return true;

+}

+

+static LLWidgetNameRegistry::StaticRegistrar sRegisterPanelDeletableWearableListItem(&typeid(LLPanelDeletableWearableListItem::Params), "deletable_wearable_list_item");

+

+LLPanelDeletableWearableListItem::Params::Params()

+:   delete_btn("delete_btn")

+{}

+

+// static

+LLPanelDeletableWearableListItem* LLPanelDeletableWearableListItem::create(LLViewerInventoryItem* item)

+{

+    LLPanelDeletableWearableListItem* list_item = NULL;

+    if(item)

+    {

+        const Params& params = LLUICtrlFactory::getDefaultParams<LLPanelDeletableWearableListItem>();

+        list_item = new LLPanelDeletableWearableListItem(item, params);

+        list_item->initFromParams(params);

+        list_item->postBuild();

+    }

+    return list_item;

+}

+

+LLPanelDeletableWearableListItem::LLPanelDeletableWearableListItem(LLViewerInventoryItem* item, const LLPanelDeletableWearableListItem::Params& params)

+: LLPanelWearableListItem(item, params)

+{

+    LLButton::Params button_params = params.delete_btn;

+    applyXUILayout(button_params, this);

+    addChild(LLUICtrlFactory::create<LLButton>(button_params));

+

+    setSeparatorVisible(true);

+}

+

+bool LLPanelDeletableWearableListItem::postBuild()

+{

+    LLPanelWearableListItem::postBuild();

+

+    addWidgetToLeftSide("btn_delete");

+

+    LLButton* delete_btn = getChild<LLButton>("btn_delete");

+    // Reserve space for 'delete' button event if it is invisible.

+    setLeftWidgetsWidth(delete_btn->getRect().mRight);

+

+    setWidgetsVisible(false);

+    reshapeWidgets();

+

+    return true;

+}

+

+

+// static

+LLPanelAttachmentListItem* LLPanelAttachmentListItem::create(LLViewerInventoryItem* item)

+{

+    LLPanelAttachmentListItem* list_item = NULL;

+    if(item)

+    {

+        const Params& params = LLUICtrlFactory::getDefaultParams<LLPanelDeletableWearableListItem>();

+

+        list_item = new LLPanelAttachmentListItem(item, params);

+        list_item->initFromParams(params);

+        list_item->postBuild();

+    }

+    return list_item;

+}

+

+void LLPanelAttachmentListItem::updateItem(const std::string& name,

+                                           EItemState item_state)

+{

+    std::string title_joint = name;

+

+    LLViewerInventoryItem* inv_item = getItem();

+    if (inv_item && isAgentAvatarValid() && gAgentAvatarp->isWearingAttachment(inv_item->getLinkedUUID()))

+    {

+        std::string found_name;

+        bool found = gAgentAvatarp->getAttachedPointName(inv_item->getLinkedUUID(),found_name);

+        std::string trans_name = LLTrans::getString(found_name);

+        if (!found)

+        {

+            LL_WARNS() << "invalid attachment joint, err " << found_name << LL_ENDL;

+        }

+        title_joint =  title_joint + " (" + trans_name + ")";

+    }

+

+    LLPanelInventoryListItemBase::updateItem(title_joint, item_state);

+}

+

+//////////////////////////////////////////////////////////////////////////

+//////////////////////////////////////////////////////////////////////////

+//////////////////////////////////////////////////////////////////////////

+static LLWidgetNameRegistry::StaticRegistrar sRegisterPanelDummyClothingListItem(&typeid(LLPanelDummyClothingListItem::Params), "dummy_clothing_list_item");

+

+LLPanelDummyClothingListItem::Params::Params()

+:   add_panel("add_panel"),

+    add_btn("add_btn")

+{}

+

+LLPanelDummyClothingListItem* LLPanelDummyClothingListItem::create(LLWearableType::EType w_type)

+{

+    const Params& params = LLUICtrlFactory::getDefaultParams<LLPanelDummyClothingListItem>();

+

+    LLPanelDummyClothingListItem* list_item = new LLPanelDummyClothingListItem(w_type, params);

+    list_item->initFromParams(params);

+    list_item->postBuild();

+    return list_item;

+}

+

+bool LLPanelDummyClothingListItem::postBuild()

+{

+    addWidgetToRightSide("btn_add_panel");

+

+    setIconImage(LLInventoryIcon::getIcon(LLAssetType::AT_CLOTHING, LLInventoryType::IT_NONE, mWearableType, false));

+    updateItem(wearableTypeToString(mWearableType));

+

+    // Make it look loke clothing item - reserve space for 'delete' button

+    setLeftWidgetsWidth(getChildView("item_icon")->getRect().mLeft);

+

+    setWidgetsVisible(false);

+    reshapeWidgets();

+

+    return true;

+}

+

+LLWearableType::EType LLPanelDummyClothingListItem::getWearableType() const

+{

+    return mWearableType;

+}

+

+LLPanelDummyClothingListItem::LLPanelDummyClothingListItem(LLWearableType::EType w_type, const LLPanelDummyClothingListItem::Params& params)

+:   LLPanelWearableListItem(NULL, params),

+    mWearableType(w_type)

+{

+    LLPanel::Params panel_params(params.add_panel);

+    applyXUILayout(panel_params, this);

+    LLPanel* add_panelp = LLUICtrlFactory::create<LLPanel>(panel_params);

+    addChild(add_panelp);

+

+    if (add_panelp)

+{

+        LLButton::Params button_params(params.add_btn);

+        applyXUILayout(button_params, this);

+        add_panelp->addChild(LLUICtrlFactory::create<LLButton>(button_params));

+}

+

+    setSeparatorVisible(true);

+}

+

+typedef std::map<LLWearableType::EType, std::string> clothing_to_string_map_t;

+

+clothing_to_string_map_t init_clothing_string_map()

+{

+    clothing_to_string_map_t w_map;

+    w_map.insert(std::make_pair(LLWearableType::WT_SHIRT, "shirt_not_worn"));

+    w_map.insert(std::make_pair(LLWearableType::WT_PANTS, "pants_not_worn"));

+    w_map.insert(std::make_pair(LLWearableType::WT_SHOES, "shoes_not_worn"));

+    w_map.insert(std::make_pair(LLWearableType::WT_SOCKS, "socks_not_worn"));

+    w_map.insert(std::make_pair(LLWearableType::WT_JACKET, "jacket_not_worn"));

+    w_map.insert(std::make_pair(LLWearableType::WT_GLOVES, "gloves_not_worn"));

+    w_map.insert(std::make_pair(LLWearableType::WT_UNDERSHIRT, "undershirt_not_worn"));

+    w_map.insert(std::make_pair(LLWearableType::WT_UNDERPANTS, "underpants_not_worn"));

+    w_map.insert(std::make_pair(LLWearableType::WT_SKIRT, "skirt_not_worn"));

+    w_map.insert(std::make_pair(LLWearableType::WT_ALPHA, "alpha_not_worn"));

+    w_map.insert(std::make_pair(LLWearableType::WT_TATTOO, "tattoo_not_worn"));

+    w_map.insert(std::make_pair(LLWearableType::WT_UNIVERSAL, "universal_not_worn"));

+    w_map.insert(std::make_pair(LLWearableType::WT_PHYSICS, "physics_not_worn"));

+    return w_map;

+}

+

+std::string LLPanelDummyClothingListItem::wearableTypeToString(LLWearableType::EType w_type)

+{

+    static const clothing_to_string_map_t w_map = init_clothing_string_map();

+    static const std::string invalid_str = LLTrans::getString("invalid_not_worn");

+

+    std::string type_str = invalid_str;

+    clothing_to_string_map_t::const_iterator it = w_map.find(w_type);

+    if(w_map.end() != it)

+    {

+        type_str = LLTrans::getString(it->second);

+    }

+    return type_str;

+}

+

+//////////////////////////////////////////////////////////////////////////

+//////////////////////////////////////////////////////////////////////////

+//////////////////////////////////////////////////////////////////////////

+

+LLWearableItemTypeNameComparator::LLWearableTypeOrder::LLWearableTypeOrder(LLWearableItemTypeNameComparator::ETypeListOrder order_priority, bool sort_asset_by_name, bool sort_wearable_by_name):

+        mOrderPriority(order_priority),

+        mSortAssetTypeByName(sort_asset_by_name),

+        mSortWearableTypeByName(sort_wearable_by_name)

+{

+}

+

+LLWearableItemTypeNameComparator::LLWearableItemTypeNameComparator()

+{

+    // By default the sort order conforms the order by spec of MY OUTFITS items list:

+    // 1. CLOTHING - sorted by name

+    // 2. OBJECT   - sorted by type

+    // 3. BODYPART - sorted by name

+    mWearableOrder[LLAssetType::AT_CLOTHING] = LLWearableTypeOrder(ORDER_RANK_1, false, false);

+    mWearableOrder[LLAssetType::AT_OBJECT]   = LLWearableTypeOrder(ORDER_RANK_2, true, true);

+    mWearableOrder[LLAssetType::AT_BODYPART] = LLWearableTypeOrder(ORDER_RANK_3, false, true);

+    mWearableOrder[LLAssetType::AT_GESTURE] = LLWearableTypeOrder(ORDER_RANK_4, true, false);

+}

+

+void LLWearableItemTypeNameComparator::setOrder(LLAssetType::EType items_of_type,  LLWearableItemTypeNameComparator::ETypeListOrder order_priority, bool sort_asset_items_by_name, bool sort_wearable_items_by_name)

+{

+    mWearableOrder[items_of_type] = LLWearableTypeOrder(order_priority, sort_asset_items_by_name, sort_wearable_items_by_name);

+}

+

+/*virtual*/

+bool LLWearableItemNameComparator::doCompare(const LLPanelInventoryListItemBase* wearable_item1, const LLPanelInventoryListItemBase* wearable_item2) const

+{

+    std::string name1 = wearable_item1->getItemName();

+    std::string name2 = wearable_item2->getItemName();

+

+    LLStringUtil::toUpper(name1);

+    LLStringUtil::toUpper(name2);

+

+    return name1 < name2;

+}

+

+/*virtual*/

+bool LLWearableItemTypeNameComparator::doCompare(const LLPanelInventoryListItemBase* wearable_item1, const LLPanelInventoryListItemBase* wearable_item2) const

+{

+    const LLAssetType::EType item_type1 = wearable_item1->getType();

+    const LLAssetType::EType item_type2 = wearable_item2->getType();

+

+    LLWearableItemTypeNameComparator::ETypeListOrder item_type_order1 = getTypeListOrder(item_type1);

+    LLWearableItemTypeNameComparator::ETypeListOrder item_type_order2 = getTypeListOrder(item_type2);

+

+    if (item_type_order1 != item_type_order2)

+    {

+        // If items are of different asset types we can compare them

+        // by types order in the list.

+        return item_type_order1 < item_type_order2;

+    }

+

+    if (sortAssetTypeByName(item_type1))

+    {

+        // If both items are of the same asset type except AT_CLOTHING and AT_BODYPART

+        // we can compare them by name.

+        return LLWearableItemNameComparator::doCompare(wearable_item1, wearable_item2);

+    }

+

+    const LLWearableType::EType item_wearable_type1 = wearable_item1->getWearableType();

+    const LLWearableType::EType item_wearable_type2 = wearable_item2->getWearableType();

+

+    if (item_wearable_type1 != item_wearable_type2)

+        // If items are of different LLWearableType::EType types they are compared

+        // by LLWearableType::EType. types order determined in LLWearableType::EType.

+    {

+        // If items are of different LLWearableType::EType types they are compared

+        // by LLWearableType::EType. types order determined in LLWearableType::EType.

+        return item_wearable_type1 < item_wearable_type2;

+    }

+    else

+    {

+        // If both items are of the same clothing type they are compared

+        // by description and place in reverse order (i.e. outer layer item

+        // on top) OR by name

+        if(sortWearableTypeByName(item_type1))

+        {

+            return LLWearableItemNameComparator::doCompare(wearable_item1, wearable_item2);

+        }

+        return wearable_item1->getDescription() > wearable_item2->getDescription();

+    }

+}

+

+LLWearableItemTypeNameComparator::ETypeListOrder LLWearableItemTypeNameComparator::getTypeListOrder(LLAssetType::EType item_type) const

+{

+    wearable_type_order_map_t::const_iterator const_it = mWearableOrder.find(item_type);

+

+

+    if(const_it == mWearableOrder.end())

+    {

+        LL_WARNS()<<"Absent information about order rang of items of "<<LLAssetType::getDesc(item_type)<<" type"<<LL_ENDL;

+        return ORDER_RANK_UNKNOWN;

+    }

+

+    return const_it->second.mOrderPriority;

+}

+

+bool LLWearableItemTypeNameComparator::sortAssetTypeByName(LLAssetType::EType item_type) const

+{

+    wearable_type_order_map_t::const_iterator const_it = mWearableOrder.find(item_type);

+

+

+    if(const_it == mWearableOrder.end())

+    {

+        LL_WARNS()<<"Absent information about sorting items of "<<LLAssetType::getDesc(item_type)<<" type"<<LL_ENDL;

+        return true;

+    }

+

+

+    return const_it->second.mSortAssetTypeByName;

+    }

+

+

+bool LLWearableItemTypeNameComparator::sortWearableTypeByName(LLAssetType::EType item_type) const

+{

+    wearable_type_order_map_t::const_iterator const_it = mWearableOrder.find(item_type);

+

+

+    if(const_it == mWearableOrder.end())

+    {

+        LL_WARNS()<<"Absent information about sorting items of "<<LLAssetType::getDesc(item_type)<<" type"<<LL_ENDL;

+        return true;

+}

+

+

+    return const_it->second.mSortWearableTypeByName;

+}

+

+/*virtual*/

+bool LLWearableItemCreationDateComparator::doCompare(const LLPanelInventoryListItemBase* item1, const LLPanelInventoryListItemBase* item2) const

+{

+    time_t date1 = item1->getCreationDate();

+    time_t date2 = item2->getCreationDate();

+

+    if (date1 == date2)

+    {

+        return LLWearableItemNameComparator::doCompare(item1, item2);

+    }

+

+    return date1 > date2;

+}

+//////////////////////////////////////////////////////////////////////////

+//////////////////////////////////////////////////////////////////////////

+//////////////////////////////////////////////////////////////////////////

+

+static LLWearableItemTypeNameComparator WEARABLE_TYPE_NAME_COMPARATOR;

+static const LLWearableItemTypeNameComparator WEARABLE_TYPE_LAYER_COMPARATOR;

+static const LLWearableItemNameComparator WEARABLE_NAME_COMPARATOR;

+static const LLWearableItemCreationDateComparator WEARABLE_CREATION_DATE_COMPARATOR;

+

+static const LLDefaultChildRegistry::Register<LLWearableItemsList> r("wearable_items_list");

+

+LLWearableItemsList::Params::Params()

+:   standalone("standalone", true)

+,   worn_indication_enabled("worn_indication_enabled", true)

+,   show_item_widgets("show_item_widgets", false)

+{}

+

+LLWearableItemsList::LLWearableItemsList(const LLWearableItemsList::Params& p)

+:   LLInventoryItemsList(p)

+{

+    setSortOrder(E_SORT_BY_TYPE_LAYER, false);

+    mMenuWearableType = LLWearableType::WT_NONE;

+    mIsStandalone = p.standalone;

+    if (mIsStandalone)

+    {

+        // Use built-in context menu.

+        setRightMouseDownCallback(boost::bind(&LLWearableItemsList::onRightClick, this, _2, _3));

+    }

+    mWornIndicationEnabled = p.worn_indication_enabled;

+    setNoItemsCommentText(LLTrans::getString("LoadingData"));

+    mShowItemWidgets = p.show_item_widgets;

+}

+

+// virtual

+LLWearableItemsList::~LLWearableItemsList()

+{}

+

+// virtual

+LLPanel* LLWearableItemsList::createNewItem(LLViewerInventoryItem* item)

+{

+    if (!item)

+    {

+        LL_WARNS() << "No inventory item. Couldn't create flat list item." << LL_ENDL;

+        llassert(item != NULL);

+        return NULL;

+    }

+

+    return LLPanelWearableOutfitItem::create(item, mWornIndicationEnabled, mShowItemWidgets);

+}

+

+void LLWearableItemsList::updateList(const LLUUID& category_id)

+{

+    LLInventoryModel::cat_array_t cat_array;

+    LLInventoryModel::item_array_t item_array;

+

+    LLFindOutfitItems collector = LLFindOutfitItems();

+    // collectDescendentsIf takes non-const reference:

+    gInventory.collectDescendentsIf(

+        category_id,

+        cat_array,

+        item_array,

+        LLInventoryModel::EXCLUDE_TRASH,

+        collector);

+

+    if(item_array.empty() && gInventory.isCategoryComplete(category_id))

+    {

+        setNoItemsCommentText(LLTrans::getString("EmptyOutfitText"));

+    }

+

+    refreshList(item_array);

+}

+

+void LLWearableItemsList::updateChangedItems(const uuid_vec_t& changed_items_uuids)

+{

+    // nothing to update

+    if (changed_items_uuids.empty())

+        return;

+

+    uuid_vec_t::const_iterator uuids_begin = changed_items_uuids.begin(), uuids_end = changed_items_uuids.end();

+    pairs_const_iterator_t pairs_iter = getItemPairs().begin(), pairs_end = getItemPairs().end();

+    while (pairs_iter != pairs_end)

+    {

+        LLPanel* panel = (*(pairs_iter++))->first;

+        LLPanelInventoryListItemBase* item = dynamic_cast<LLPanelInventoryListItemBase*>(panel);

+        if (!item)

+            continue;

+

+        LLViewerInventoryItem* inv_item = item->getItem();

+        if (!inv_item)

+            continue;

+

+        const LLUUID& linked_uuid = inv_item->getLinkedUUID();

+        if (std::find(uuids_begin, uuids_end, linked_uuid) != uuids_end)

+        {

+            item->setNeedsRefresh(true);

+        }

+    }

+}

+

+void LLWearableItemsList::onRightClick(S32 x, S32 y)

+{

+    uuid_vec_t selected_uuids;

+

+    getSelectedUUIDs(selected_uuids);

+    if (selected_uuids.empty())

+    {

+        if ((mMenuWearableType != LLWearableType::WT_NONE) && (size() == 0))

+        {

+            ContextMenu::instance().show(this, mMenuWearableType, x, y);

+        }

+    }

+    else

+    {

+        ContextMenu::instance().show(this, selected_uuids, x, y);

+    }

+}

+

+void LLWearableItemsList::setSortOrder(ESortOrder sort_order, bool sort_now)

+{

+    switch (sort_order)

+    {

+    case E_SORT_BY_MOST_RECENT:

+        setComparator(&WEARABLE_CREATION_DATE_COMPARATOR);

+        break;

+    case E_SORT_BY_NAME:

+        setComparator(&WEARABLE_NAME_COMPARATOR);

+        break;

+    case E_SORT_BY_TYPE_LAYER:

+        setComparator(&WEARABLE_TYPE_LAYER_COMPARATOR);

+        break;

+    case E_SORT_BY_TYPE_NAME:

+    {

+        WEARABLE_TYPE_NAME_COMPARATOR.setOrder(LLAssetType::AT_CLOTHING, LLWearableItemTypeNameComparator::ORDER_RANK_1, false, true);

+        setComparator(&WEARABLE_TYPE_NAME_COMPARATOR);

+        break;

+    }

+

+    // No "default:" to raise compiler warning

+    // if we're not handling something

+    }

+

+    mSortOrder = sort_order;

+

+    if (sort_now)

+    {

+        sort();

+    }

+}

+

+//////////////////////////////////////////////////////////////////////////

+/// ContextMenu

+//////////////////////////////////////////////////////////////////////////

+

+LLWearableItemsList::ContextMenu::ContextMenu()

+:   mParent(NULL)

+{

+}

+

+void LLWearableItemsList::ContextMenu::show(LLView* spawning_view, const uuid_vec_t& uuids, S32 x, S32 y)

+{

+    mParent = dynamic_cast<LLWearableItemsList*>(spawning_view);

+    LLListContextMenu::show(spawning_view, uuids, x, y);

+    mParent = NULL; // to avoid dereferencing an invalid pointer

+}

+

+void LLWearableItemsList::ContextMenu::show(LLView* spawning_view, LLWearableType::EType w_type, S32 x, S32 y)

+{

+    mParent = dynamic_cast<LLWearableItemsList*>(spawning_view);

+    LLContextMenu* menup = mMenuHandle.get();

+    if (menup)

+    {

+        //preventing parent (menu holder) from deleting already "dead" context menus on exit

+        LLView* parent = menup->getParent();

+        if (parent)

+        {

+            parent->removeChild(menup);

+        }

+        delete menup;

+        mUUIDs.clear();

+    }

+

+    LLUICtrl::CommitCallbackRegistry::ScopedRegistrar registrar;

+    registrar.add("Wearable.CreateNew", boost::bind(createNewWearableByType, w_type));

+    menup = createFromFile("menu_wearable_list_item.xml");

+    if (!menup)

+    {

+        LL_WARNS() << "Context menu creation failed" << LL_ENDL;

+        return;

+    }

+    setMenuItemVisible(menup, "create_new", true);

+    setMenuItemEnabled(menup, "create_new", true);

+    setMenuItemVisible(menup, "wearable_attach_to", false);

+    setMenuItemVisible(menup, "wearable_attach_to_hud", false);

+

+    std::string new_label = LLTrans::getString("create_new_" + LLWearableType::getInstance()->getTypeName(w_type));

+    LLMenuItemGL* menu_item = menup->getChild<LLMenuItemGL>("create_new");

+    menu_item->setLabel(new_label);

+

+    mMenuHandle = menup->getHandle();

+    menup->show(x, y);

+    LLMenuGL::showPopup(spawning_view, menup, x, y);

+

+    mParent = NULL; // to avoid dereferencing an invalid pointer

+}

+

+// virtual

+LLContextMenu* LLWearableItemsList::ContextMenu::createMenu()

+{

+    LLUICtrl::CommitCallbackRegistry::ScopedRegistrar registrar;

+    const uuid_vec_t& ids = mUUIDs;     // selected items IDs

+    LLUUID selected_id = ids.front();   // ID of the first selected item

+

+    // Register handlers common for all wearable types.

+    registrar.add("Wearable.Wear", boost::bind(wear_multiple, ids, true));

+    registrar.add("Wearable.Add", boost::bind(wear_multiple, ids, false));

+    registrar.add("Wearable.Edit", boost::bind(handle_item_edit, selected_id));

+    registrar.add("Wearable.CreateNew", boost::bind(createNewWearable, selected_id));

+    registrar.add("Wearable.ShowOriginal", boost::bind(show_item_original, selected_id));

+    registrar.add("Wearable.TakeOffDetach",

+                  boost::bind(&LLAppearanceMgr::removeItemsFromAvatar, LLAppearanceMgr::getInstance(), ids, no_op));

+

+    // Register handlers for clothing.

+    registrar.add("Clothing.TakeOff",

+                  boost::bind(&LLAppearanceMgr::removeItemsFromAvatar, LLAppearanceMgr::getInstance(), ids, no_op));

+

+    // Register handlers for body parts.

+

+    // Register handlers for attachments.

+    registrar.add("Attachment.Detach",

+                  boost::bind(&LLAppearanceMgr::removeItemsFromAvatar, LLAppearanceMgr::getInstance(), ids, no_op));

+    registrar.add("Attachment.Touch", boost::bind(handle_attachment_touch, selected_id));

+    registrar.add("Attachment.Profile", boost::bind(show_item_profile, selected_id));

+    registrar.add("Object.Attach", boost::bind(LLViewerAttachMenu::attachObjects, ids, _2));

+

+    // Create the menu.

+    LLContextMenu* menu = createFromFile("menu_wearable_list_item.xml");

+

+    // Determine which items should be visible/enabled.

+    updateItemsVisibility(menu);

+

+    // Update labels for the items requiring that.

+    updateItemsLabels(menu);

+    return menu;

+}

+

+void LLWearableItemsList::ContextMenu::updateItemsVisibility(LLContextMenu* menu)

+{

+    if (!menu)

+    {

+        LL_WARNS() << "Invalid menu" << LL_ENDL;

+        return;

+    }

+

+    const uuid_vec_t& ids = mUUIDs; // selected items IDs

+    U32 mask = 0;                   // mask of selected items' types

+    U32 n_items = ids.size();       // number of selected items

+    U32 n_worn = 0;                 // number of worn items among the selected ones

+    U32 n_already_worn = 0;         // number of items worn of same type as selected items

+    U32 n_links = 0;                // number of links among the selected items

+    U32 n_editable = 0;             // number of editable items among the selected ones

+    U32 n_touchable = 0;            // number of touchable items among the selected ones

+

+    bool can_be_worn = true;

+

+    for (uuid_vec_t::const_iterator it = ids.begin(); it != ids.end(); ++it)

+    {

+        LLUUID id = *it;

+        LLViewerInventoryItem* item = gInventory.getItem(id);

+

+        if (!item)

+        {

+            LL_WARNS() << "Invalid item" << LL_ENDL;

+            // *NOTE: the logic below may not work in this case

+            continue;

+        }

+

+        updateMask(mask, item->getType());

+

+        const LLWearableType::EType wearable_type = item->getWearableType();

+        const bool is_link = item->getIsLinkType();

+        const bool is_worn = get_is_item_worn(id);

+        const bool is_editable = get_is_item_editable(id);

+        const bool is_touchable = enable_attachment_touch(id);

+        const bool is_already_worn = gAgentWearables.selfHasWearable(wearable_type);

+        if (is_worn)

+        {

+            ++n_worn;

+        }

+        if (is_touchable)

+        {

+            ++n_touchable;

+        }

+        if (is_editable)

+        {

+            ++n_editable;

+        }

+        if (is_link)

+        {

+            ++n_links;

+        }

+        if (is_already_worn)

+        {

+            ++n_already_worn;

+        }

+

+        if (can_be_worn)

+        {

+            can_be_worn = get_can_item_be_worn(item->getLinkedUUID());

+        }

+    } // for

+

+    bool standalone = mParent ? mParent->isStandalone() : false;

+    bool wear_add_visible = mask & (MASK_CLOTHING|MASK_ATTACHMENT) && n_worn == 0 && can_be_worn && (n_already_worn != 0 || mask & MASK_ATTACHMENT);

+

+    // *TODO: eliminate multiple traversals over the menu items

+    setMenuItemVisible(menu, "wear_wear",           n_already_worn == 0 && n_worn == 0 && can_be_worn);

+    setMenuItemEnabled(menu, "wear_wear",           n_already_worn == 0 && n_worn == 0);

+    setMenuItemVisible(menu, "wear_add",            wear_add_visible);

+    setMenuItemEnabled(menu, "wear_add",            LLAppearanceMgr::instance().canAddWearables(ids));

+    setMenuItemVisible(menu, "wear_replace",        n_worn == 0 && n_already_worn != 0 && can_be_worn);

+    //visible only when one item selected and this item is worn

+    setMenuItemVisible(menu, "touch",               !standalone && mask == MASK_ATTACHMENT && n_worn == n_items);

+    setMenuItemEnabled(menu, "touch",               n_touchable && n_worn == 1 && n_items == 1);

+    setMenuItemVisible(menu, "edit",                !standalone && mask & (MASK_CLOTHING|MASK_BODYPART|MASK_ATTACHMENT) && n_worn == n_items);

+    setMenuItemEnabled(menu, "edit",                n_editable && n_worn == 1 && n_items == 1);

+    setMenuItemVisible(menu, "create_new",          mask & (MASK_CLOTHING|MASK_BODYPART) && n_items == 1);

+    setMenuItemEnabled(menu, "create_new",          LLAppearanceMgr::instance().canAddWearables(ids));

+    setMenuItemVisible(menu, "show_original",       !standalone);

+    setMenuItemEnabled(menu, "show_original",       n_items == 1 && n_links == n_items);

+    setMenuItemVisible(menu, "take_off",            mask == MASK_CLOTHING && n_worn == n_items);

+    setMenuItemVisible(menu, "detach",              mask == MASK_ATTACHMENT && n_worn == n_items);

+    setMenuItemVisible(menu, "take_off_or_detach",  mask == (MASK_ATTACHMENT|MASK_CLOTHING));

+    setMenuItemEnabled(menu, "take_off_or_detach",  n_worn == n_items);

+    setMenuItemVisible(menu, "object_profile",      !standalone);

+    setMenuItemEnabled(menu, "object_profile",      n_items == 1);

+    setMenuItemVisible(menu, "--no options--",      false);

+    setMenuItemEnabled(menu, "--no options--",      false);

+

+    // Populate or hide the "Attach to..." / "Attach to HUD..." submenus.

+    if (mask == MASK_ATTACHMENT && n_worn == 0)

+    {

+        LLViewerAttachMenu::populateMenus("wearable_attach_to", "wearable_attach_to_hud");

+    }

+    else

+    {

+        setMenuItemVisible(menu, "wearable_attach_to",          false);

+        setMenuItemVisible(menu, "wearable_attach_to_hud",      false);

+    }

+

+    if (mask & MASK_UNKNOWN)

+    {

+        LL_WARNS() << "Non-wearable items passed." << LL_ENDL;

+    }

+

+    U32 num_visible_items = 0;

+    for (U32 menu_item_index = 0; menu_item_index < menu->getItemCount(); ++menu_item_index)

+    {

+        const LLMenuItemGL* menu_item = menu->getItem(menu_item_index);

+        if (menu_item && menu_item->getVisible())

+        {

+            num_visible_items++;

+        }

+    }

+    if (num_visible_items == 0)

+    {

+        setMenuItemVisible(menu, "--no options--", true);

+    }

+}

+

+void LLWearableItemsList::ContextMenu::updateItemsLabels(LLContextMenu* menu)

+{

+    llassert(menu);

+    if (!menu) return;

+

+    // Set proper label for the "Create new <WEARABLE_TYPE>" menu item.

+    LLViewerInventoryItem* item = gInventory.getLinkedItem(mUUIDs.back());

+    if (!item || !item->isWearableType()) return;

+

+    LLWearableType::EType w_type = item->getWearableType();

+    std::string new_label = LLTrans::getString("create_new_" + LLWearableType::getInstance()->getTypeName(w_type));

+

+    LLMenuItemGL* menu_item = menu->getChild<LLMenuItemGL>("create_new");

+    menu_item->setLabel(new_label);

+}

+

+// We need this method to convert non-zero bool values to exactly 1 (true).

+// Otherwise code relying on a bool value being true may fail

+// (I experienced a weird assert in LLView::drawChildren() because of that.

+// static

+void LLWearableItemsList::ContextMenu::setMenuItemVisible(LLContextMenu* menu, const std::string& name, bool val)

+{

+    menu->setItemVisible(name, val);

+}

+

+// static

+void LLWearableItemsList::ContextMenu::setMenuItemEnabled(LLContextMenu* menu, const std::string& name, bool val)

+{

+    menu->setItemEnabled(name, val);

+}

+

+// static

+void LLWearableItemsList::ContextMenu::updateMask(U32& mask, LLAssetType::EType at)

+{

+    if (at == LLAssetType::AT_CLOTHING)

+    {

+        mask |= MASK_CLOTHING;

+    }

+    else if (at == LLAssetType::AT_BODYPART)

+    {

+        mask |= MASK_BODYPART;

+    }

+    else if (at == LLAssetType::AT_OBJECT)

+    {

+        mask |= MASK_ATTACHMENT;

+    }

+    else if (at == LLAssetType::AT_GESTURE)

+    {

+        mask |= MASK_GESTURE;

+    }

+    else

+    {

+        mask |= MASK_UNKNOWN;

+    }

+}

+

+// static

+void LLWearableItemsList::ContextMenu::createNewWearable(const LLUUID& item_id)

+{

+    LLViewerInventoryItem* item = gInventory.getLinkedItem(item_id);

+    if (!item || !item->isWearableType()) return;

+

+    LLAgentWearables::createWearable(item->getWearableType(), true);

+}

+

+// static

+void LLWearableItemsList::ContextMenu::createNewWearableByType(LLWearableType::EType type)

+{

+    LLAgentWearables::createWearable(type, true);

+}

+

+// EOF