1 files changed, 460 insertions, 69 deletions

diff --git a/indra/newview/llpanelplaces.cpp b/indra/newview/llpanelplaces.cpp
index d18cac9f42..31b2d01dcf 100644
--- a/indra/newview/llpanelplaces.cpp
+++ b/indra/newview/llpanelplaces.cpp
@@ -31,32 +31,51 @@
 
 #include "llviewerprecompiledheaders.h"
 
+#include "llassettype.h"
+
+#include "lllandmark.h"
+
 #include "llfloaterreg.h"
-#include "llsearcheditor.h"
+#include "llnotifications.h"
+#include "llfiltereditor.h"
 #include "lltabcontainer.h"
+#include "lltrans.h"
 #include "lluictrlfactory.h"
 
-#include "lllandmark.h"
-
 #include "llagent.h"
 #include "lllandmarklist.h"
 #include "llfloaterworldmap.h"
 #include "llpanelplaces.h"
 #include "llpanellandmarks.h"
 #include "llpanelteleporthistory.h"
+#include "llsidetray.h"
+#include "lltoggleablemenu.h"
+#include "llviewerparcelmgr.h"
 #include "llviewerregion.h"
 
+// Helper functions
+static bool cmp_folders(const folder_pair_t& left, const folder_pair_t& right);
+static std::string getFullFolderName(const LLViewerInventoryCategory* cat);
+static void collectLandmarkFolders(LLInventoryModel::cat_array_t& cats);
+static const LLVector3 get_pos_local_from_global(const LLVector3d &pos_global);
+
 static LLRegisterPanelClassWrapper<LLPanelPlaces> t_places("panel_places");
 
 LLPanelPlaces::LLPanelPlaces()
 	:	LLPanel(),
 		mFilterSubString(LLStringUtil::null),
 		mActivePanel(NULL),
-		mSearchEditor(NULL),
-		mPlaceInfo(NULL)
+		mFilterEditor(NULL),
+		mPlaceInfo(NULL),
+		mItem(NULL),
+		mLandmarkFoldersMenuHandle(),
+		mPosGlobal()
 {
 	gInventory.addObserver(this);
 
+	LLViewerParcelMgr::getInstance()->setAgentParcelChangedCallback(
+			boost::bind(&LLPanelPlaces::onAgentParcelChange, this));
+
 	//LLUICtrlFactory::getInstance()->buildPanel(this, "panel_places.xml"); // Called from LLRegisterPanelClass::defaultPanelClassBuilder()
 }
 
@@ -64,23 +83,42 @@ LLPanelPlaces::~LLPanelPlaces()
 {
 	if (gInventory.containsObserver(this))
 		gInventory.removeObserver(this);
+	
+	LLView::deleteViewByHandle(mLandmarkFoldersMenuHandle);
 }
 
 BOOL LLPanelPlaces::postBuild()
 {
+	mCreateLandmarkBtn = getChild<LLButton>("create_landmark_btn");
+	mCreateLandmarkBtn->setClickedCallback(boost::bind(&LLPanelPlaces::onCreateLandmarkButtonClicked, this, LLUUID()));
+	
+	mFolderMenuBtn = getChild<LLButton>("folder_menu_btn");
+	mFolderMenuBtn->setClickedCallback(boost::bind(&LLPanelPlaces::showLandmarkFoldersMenu, this));
+
+	mTeleportBtn = getChild<LLButton>("teleport_btn");
+	mTeleportBtn->setClickedCallback(boost::bind(&LLPanelPlaces::onTeleportButtonClicked, this));
+	
+	mShowOnMapBtn = getChild<LLButton>("map_btn");
+	mShowOnMapBtn->setClickedCallback(boost::bind(&LLPanelPlaces::onShowOnMapButtonClicked, this));
+	
+	mShareBtn = getChild<LLButton>("share_btn");
+	//mShareBtn->setClickedCallback(boost::bind(&LLPanelPlaces::onShareButtonClicked, this));
+
+	mOverflowBtn = getChild<LLButton>("overflow_btn");
+
 	mTabContainer = getChild<LLTabContainer>("Places Tabs");
 	if (mTabContainer)
 	{
 		mTabContainer->setCommitCallback(boost::bind(&LLPanelPlaces::onTabSelected, this));
 	}
 
-	mSearchEditor = getChild<LLSearchEditor>("Filter");
-	if (mSearchEditor)
+	mFilterEditor = getChild<LLFilterEditor>("Filter");
+	if (mFilterEditor)
 	{
-		mSearchEditor->setSearchCallback(boost::bind(&LLPanelPlaces::onSearchEdit, this, _1));
+		mFilterEditor->setCommitCallback(boost::bind(&LLPanelPlaces::onFilterEdit, this, _2));
 	}
 
-	mPlaceInfo = dynamic_cast<LLPanelPlaceInfo*>(getChild<LLPanel>("panel_landmark_info"));
+	mPlaceInfo = getChild<LLPanelPlaceInfo>("panel_place_info", TRUE, FALSE);
 	if (mPlaceInfo)
 	{
 		LLButton* back_btn = mPlaceInfo->getChild<LLButton>("back_btn");
@@ -88,60 +126,64 @@ BOOL LLPanelPlaces::postBuild()
 		{
 			back_btn->setClickedCallback(boost::bind(&LLPanelPlaces::onBackButtonClicked, this));
 		}
-	}
 
-	//childSetAction("share_btn", boost::bind(&LLPanelPlaces::onShareButtonClicked, this), this);
-	childSetAction("teleport_btn", boost::bind(&LLPanelPlaces::onTeleportButtonClicked, this), this);
-	childSetAction("map_btn", boost::bind(&LLPanelPlaces::onShowOnMapButtonClicked, this), this);
+		// *TODO: Assign the action to an appropriate event.
+		mOverflowBtn->setClickedCallback(boost::bind(&LLPanelPlaces::toggleMediaPanel, this));
+	}
 
 	return TRUE;
 }
 
-void LLPanelPlaces::draw()
-{
-	LLPanel::draw();
-}
-
 void LLPanelPlaces::onOpen(const LLSD& key)
 {
 	if(key.size() == 0)
 		return;
 
+	mPlaceInfoType = key["type"].asString();
+	mPosGlobal.setZero();
 	togglePlaceInfoPanel(TRUE);
-	
-	mPlaceInfoType = key["type"].asInteger();
+	updateVerbs();
 
-	if (mPlaceInfoType == AGENT)
+	if (mPlaceInfoType == "agent")
 	{
-		// We don't need to teleport to the current location so disable the button
-		getChild<LLButton>("teleport_btn")->setEnabled(FALSE);
-
-		mPlaceInfo->displayParcelInfo(gAgent.getPositionAgent(),
-									  gAgent.getRegion()->getRegionID(),
-									  gAgent.getPositionGlobal());
+		mPlaceInfo->setInfoType(LLPanelPlaceInfo::PLACE);
+		mPlaceInfo->displayAgentParcelInfo();
+		
+		mPosGlobal = gAgent.getPositionGlobal();
+	}
+	else if (mPlaceInfoType == "create_landmark")
+	{
+		mPlaceInfo->setInfoType(LLPanelPlaceInfo::CREATE_LANDMARK);
+		mPlaceInfo->displayAgentParcelInfo();
+		
+		mPosGlobal = gAgent.getPositionGlobal();
 	}
-	else if (mPlaceInfoType == LANDMARK)
+	else if (mPlaceInfoType == "landmark")
 	{
-		LLInventoryItem* item = gInventory.getItem(key["id"].asUUID());
+		LLUUID item_uuid = key["id"].asUUID();
+		LLInventoryItem* item = gInventory.getItem(item_uuid);
 		if (!item)
 			return;
+		
+		setItem(item);
+	}
+	else if (mPlaceInfoType == "remote_place")
+	{
+		if (mPlaceInfo->isMediaPanelVisible())
+		{
+			toggleMediaPanel();
+		}
 
-		mPlaceInfo->displayItemInfo(item);
-
-		LLLandmark* landmark = gLandmarkList.getAsset(item->getAssetUUID());
-		if (!landmark)
-			return;
-
-		LLUUID region_id;
-		landmark->getRegionID(region_id);
-		LLVector3d pos_global;
-		landmark->getGlobalPos(pos_global);
-		mPlaceInfo->displayParcelInfo(landmark->getRegionPos(),
-									  region_id,
-									  pos_global);
+		mPosGlobal = LLVector3d(key["x"].asReal(),
+								key["y"].asReal(),
+								key["z"].asReal());
 
+		mPlaceInfo->setInfoType(LLPanelPlaceInfo::PLACE);
+		mPlaceInfo->displayParcelInfo(get_pos_local_from_global(mPosGlobal),
+									  LLUUID(),
+									  mPosGlobal);
 	}
-	else if (mPlaceInfoType == TELEPORT_HISTORY)
+	else if (mPlaceInfoType == "teleport_history")
 	{
 		S32 index = key["id"].asInteger();
 
@@ -150,52 +192,77 @@ void LLPanelPlaces::onOpen(const LLSD& key)
 
 		LLVector3d pos_global = hist_items[index].mGlobalPos;
 
-		F32 region_x = (F32)fmod( pos_global.mdV[VX], (F64)REGION_WIDTH_METERS );
-		F32 region_y = (F32)fmod( pos_global.mdV[VY], (F64)REGION_WIDTH_METERS );
-
-		LLVector3 pos_local(region_x, region_y, (F32)pos_global.mdV[VZ]);
-
-		mPlaceInfo->displayParcelInfo(pos_local,
+		mPlaceInfo->setInfoType(LLPanelPlaceInfo::TELEPORT_HISTORY);
+		mPlaceInfo->displayParcelInfo(get_pos_local_from_global(pos_global),
 									  hist_items[index].mRegionID,
 									  pos_global);
 	}
 }
 
-void LLPanelPlaces::onSearchEdit(const std::string& search_string)
+void LLPanelPlaces::setItem(LLInventoryItem* item)
+{
+	mItem = item;
+	
+	// If the item is a link get a linked item
+	if (mItem->getType() == LLAssetType::AT_LINK)
+	{
+		mItem = gInventory.getItem(mItem->getAssetUUID());
+		if (mItem.isNull())
+			return;
+	}
+
+	mPlaceInfo->setInfoType(LLPanelPlaceInfo::LANDMARK);
+	mPlaceInfo->displayItemInfo(mItem);
+
+	LLLandmark* lm = gLandmarkList.getAsset(mItem->getAssetUUID(),
+											boost::bind(&LLPanelPlaces::onLandmarkLoaded, this, _1));
+	if (lm)
+	{
+		onLandmarkLoaded(lm);
+	}
+}
+
+void LLPanelPlaces::onLandmarkLoaded(LLLandmark* landmark)
+{
+	LLUUID region_id;
+	landmark->getRegionID(region_id);
+	LLVector3d pos_global;
+	landmark->getGlobalPos(pos_global);
+	mPlaceInfo->displayParcelInfo(landmark->getRegionPos(),
+								  region_id,
+								  pos_global);
+}
+
+void LLPanelPlaces::onFilterEdit(const std::string& search_string)
 {
 	if (mFilterSubString != search_string)
 	{
 		mFilterSubString = search_string;
 
+		// Searches are case-insensitive
 		LLStringUtil::toUpper(mFilterSubString);
 		LLStringUtil::trimHead(mFilterSubString);
 
-		mSearchEditor->setText(mFilterSubString);
-
 		mActivePanel->onSearchEdit(mFilterSubString);
 	}
 }
 
 void LLPanelPlaces::onTabSelected()
 {
+	mActivePanel = dynamic_cast<LLPanelPlacesTab*>(mTabContainer->getCurrentPanel());
 	if (!mActivePanel)
 		return;
 
-	mActivePanel = dynamic_cast<LLPanelPlacesTab*>(mTabContainer->getCurrentPanel());
-
-	if (mActivePanel)
-	{
-		mActivePanel->onSearchEdit(mFilterSubString);
-		mActivePanel->onTabSelected();
-	}
+	onFilterEdit(mFilterSubString);	
+	mActivePanel->updateVerbs();
 }
 
+/*
 void LLPanelPlaces::onShareButtonClicked()
 {
 	// TODO: Launch the "Things" Share wizard
 }
 
-/*
 void LLPanelPlaces::onAddLandmarkButtonClicked()
 {
 	LLFloaterReg::showInstance("add_landmark");
@@ -209,19 +276,64 @@ void LLPanelPlaces::onCopySLURLButtonClicked()
 
 void LLPanelPlaces::onTeleportButtonClicked()
 {
-	mActivePanel->onTeleport();
+	if (mPlaceInfo->getVisible())
+	{
+		if (mPlaceInfoType == "landmark")
+		{
+			LLSD payload;
+			payload["asset_id"] = mItem->getAssetUUID();
+			LLNotifications::instance().add("TeleportFromLandmark", LLSD(), payload);
+		}
+		else if (mPlaceInfoType == "remote_place")
+		{
+			LLFloaterWorldMap* worldmap_instance = LLFloaterWorldMap::getInstance();
+			if (!mPosGlobal.isExactlyZero() && worldmap_instance)
+			{
+				gAgent.teleportViaLocation(mPosGlobal);
+				worldmap_instance->trackLocation(mPosGlobal);
+			}
+		}
+	}
+	else
+	{
+		mActivePanel->onTeleport();
+	}
 }
 
 void LLPanelPlaces::onShowOnMapButtonClicked()
 {
-	if (!mPlaceInfoType)
+	if (mPlaceInfo->getVisible())
 	{
-		LLVector3d global_pos = gAgent.getPositionGlobal();
-		if (!global_pos.isExactlyZero())
+		LLFloaterWorldMap* worldmap_instance = LLFloaterWorldMap::getInstance();
+		if(!worldmap_instance)
+			return;
+
+		if (mPlaceInfoType == "agent" ||
+			mPlaceInfoType == "create_landmark" ||
+			mPlaceInfoType == "remote_place")
+		{
+			if (!mPosGlobal.isExactlyZero())
+			{
+				worldmap_instance->trackLocation(mPosGlobal);
+				LLFloaterReg::showInstance("world_map", "center");
+			}
+		}
+		else if (mPlaceInfoType == "landmark")
+		{
+			LLLandmark* landmark = gLandmarkList.getAsset(mItem->getAssetUUID());
+			if (!landmark)
+				return;
+
+			LLVector3d landmark_global_pos;
+			if (!landmark->getGlobalPos(landmark_global_pos))
+				return;
+			
+			if (!landmark_global_pos.isExactlyZero())
 			{
-				LLFloaterWorldMap::getInstance()->trackLocation(global_pos);
+				worldmap_instance->trackLocation(landmark_global_pos);
 				LLFloaterReg::showInstance("world_map", "center");
 			}
+		}
 	}
 	else
 	{
@@ -229,9 +341,33 @@ void LLPanelPlaces::onShowOnMapButtonClicked()
 	}
 }
 
+void LLPanelPlaces::onCreateLandmarkButtonClicked(const LLUUID& folder_id)
+{
+	if (!mPlaceInfo)
+		return;
+
+	mPlaceInfo->createLandmark(folder_id);
+
+	onBackButtonClicked();
+	LLSideTray::getInstance()->collapseSideBar();
+}
+
 void LLPanelPlaces::onBackButtonClicked()
 {
 	togglePlaceInfoPanel(FALSE);
+
+	// Resetting mPlaceInfoType when Place Info panel is closed.
+	mPlaceInfoType = LLStringUtil::null;
+
+	updateVerbs();
+}
+
+void LLPanelPlaces::toggleMediaPanel()
+{
+	if (!mPlaceInfo)
+		return;
+
+	mPlaceInfo->toggleMediaPanel(!mPlaceInfo->isMediaPanelVisible());
 }
 
 void LLPanelPlaces::togglePlaceInfoPanel(BOOL visible)
@@ -240,7 +376,7 @@ void LLPanelPlaces::togglePlaceInfoPanel(BOOL visible)
 		return;
 
 	mPlaceInfo->setVisible(visible);
-	mSearchEditor->setVisible(!visible);
+	mFilterEditor->setVisible(!visible);
 	mTabContainer->setVisible(!visible);
 
 	if (visible)
@@ -249,7 +385,7 @@ void LLPanelPlaces::togglePlaceInfoPanel(BOOL visible)
 
 		LLRect rect = getRect();
 		LLRect new_rect = LLRect(rect.mLeft, rect.mTop, rect.mRight, mTabContainer->getRect().mBottom);
-		mPlaceInfo->reshape(new_rect.getWidth(),new_rect.getHeight());
+		mPlaceInfo->reshape(new_rect.getWidth(),new_rect.getHeight());	
 	}
 }
 
@@ -267,7 +403,7 @@ void LLPanelPlaces::changed(U32 mask)
 		mTabContainer->addTabPanel(
 			LLTabContainer::TabPanelParams().
 			panel(landmarks_panel).
-			label("Landmarks").
+			label(getString("landmarks_tab_title")).
 			insert_at(LLTabContainer::END));
 	}
 
@@ -279,7 +415,7 @@ void LLPanelPlaces::changed(U32 mask)
 		mTabContainer->addTabPanel(
 			LLTabContainer::TabPanelParams().
 			panel(teleport_history_panel).
-			label("Teleport History").
+			label(getString("teleport_history_tab_title")).
 			insert_at(LLTabContainer::END));
 	}
 
@@ -291,3 +427,258 @@ void LLPanelPlaces::changed(U32 mask)
 	// so remove the observer
 	gInventory.removeObserver(this);
 }
+
+void LLPanelPlaces::onAgentParcelChange()
+{
+	if (mPlaceInfo->getVisible() && (mPlaceInfoType == "agent" || mPlaceInfoType == "create_landmark"))
+	{
+		onOpen(LLSD().insert("type", mPlaceInfoType));
+	}
+	else
+	{
+		updateVerbs();
+	}
+}
+
+void LLPanelPlaces::updateVerbs()
+{
+	bool is_place_info_visible = mPlaceInfo->getVisible();
+	bool is_agent_place_info_visible = mPlaceInfoType == "agent";
+	bool is_create_landmark_visible = mPlaceInfoType == "create_landmark";
+	
+	mTeleportBtn->setVisible(!is_create_landmark_visible);
+	mShareBtn->setVisible(!is_create_landmark_visible);
+	mCreateLandmarkBtn->setVisible(is_create_landmark_visible);
+	mFolderMenuBtn->setVisible(is_create_landmark_visible);
+
+	// Enable overflow button only when showing the information
+	// about agent's current location.
+	mOverflowBtn->setEnabled(is_agent_place_info_visible);
+
+	if (is_place_info_visible)
+	{
+		if (is_agent_place_info_visible)
+		{
+			// We don't need to teleport to the current location so disable the button
+			mTeleportBtn->setEnabled(FALSE);
+		}
+		else if (mPlaceInfoType == "landmark" || mPlaceInfoType == "remote_place")
+		{
+			mTeleportBtn->setEnabled(TRUE);
+		}
+
+		mShowOnMapBtn->setEnabled(TRUE);
+	}
+	else
+	{
+		mActivePanel->updateVerbs();
+	}
+}
+
+void LLPanelPlaces::showLandmarkFoldersMenu()
+{
+	if (mLandmarkFoldersMenuHandle.isDead())
+	{
+		LLToggleableMenu::Params menu_p;
+		menu_p.name("landmarks_folders_menu");
+		menu_p.can_tear_off(false);
+		menu_p.visible(false);
+		menu_p.scrollable(true);
+
+		LLToggleableMenu* menu = LLUICtrlFactory::create<LLToggleableMenu>(menu_p);
+
+		mLandmarkFoldersMenuHandle = menu->getHandle();
+	}
+
+	LLToggleableMenu* menu = (LLToggleableMenu*)mLandmarkFoldersMenuHandle.get();
+	if(!menu)
+		return;
+
+	if (menu->getClosedByButtonClick())
+	{
+		menu->resetClosedByButtonClick();
+		return;
+	}
+
+	if (menu->getVisible())
+	{
+		menu->setVisible(FALSE);
+		menu->resetClosedByButtonClick();
+		return;
+	}
+
+	// Collect all folders that can contain landmarks.
+	LLInventoryModel::cat_array_t cats;
+	collectLandmarkFolders(cats);
+
+	// Sort the folders by their full name.
+	folder_vec_t folders;
+	S32 count = cats.count();
+	for (S32 i = 0; i < count; i++)
+	{
+		const LLViewerInventoryCategory* cat = cats.get(i);
+		std::string cat_full_name = getFullFolderName(cat);
+		folders.push_back(folder_pair_t(cat->getUUID(), cat_full_name));
+	}
+	sort(folders.begin(), folders.end(), cmp_folders);
+
+	LLRect btn_rect = mFolderMenuBtn->getRect();
+
+	LLRect root_rect = getRootView()->getRect();
+	
+	// Check it there are changed items or viewer dimensions 
+	// have changed since last call
+	if (mLandmarkFoldersCache.size() == count &&
+		mRootViewWidth == root_rect.getWidth() &&
+		mRootViewHeight == root_rect.getHeight())
+	{
+		S32 i;
+		for (i = 0; i < count; i++)
+		{
+			if (mLandmarkFoldersCache[i].second != folders[i].second)
+			{
+				break;
+			}
+		}
+
+		// Check passed, just show the menu
+		if (i == count)
+		{
+			menu->buildDrawLabels();
+			menu->updateParent(LLMenuGL::sMenuContainer);
+
+			menu->setButtonRect(btn_rect, this);
+			LLMenuGL::showPopup(this, menu, btn_rect.mRight, btn_rect.mTop);
+			return;
+		}
+	}
+
+	// If there are changes, store the new viewer dimensions
+	// and a list of folders
+	mRootViewWidth = root_rect.getWidth();
+	mRootViewHeight = root_rect.getHeight();
+	mLandmarkFoldersCache = folders;
+
+	menu->empty();
+	U32 max_width = 0;
+
+	// Menu width must not exceed the root view limits,
+	// so we assume the space between the left edge of
+	// the root view and 
+	LLRect screen_btn_rect;
+	localRectToScreen(btn_rect, &screen_btn_rect);
+	S32 free_space = screen_btn_rect.mRight;
+
+	for(folder_vec_t::const_iterator it = mLandmarkFoldersCache.begin(); it != mLandmarkFoldersCache.end(); it++)
+	{
+		const std::string& item_name = it->second;
+
+		LLMenuItemCallGL::Params item_params;
+		item_params.name(item_name);
+		item_params.label(item_name);
+
+		item_params.on_click.function(boost::bind(&LLPanelPlaces::onCreateLandmarkButtonClicked, this, it->first));
+
+		LLMenuItemCallGL *menu_item = LLUICtrlFactory::create<LLMenuItemCallGL>(item_params);
+
+		// Check whether item name wider than menu
+		if ((S32) menu_item->getNominalWidth() > free_space)
+		{
+			S32 chars_total = item_name.length();
+			S32 chars_fitted = 1;
+			menu_item->setLabel(LLStringExplicit(""));
+			S32 label_space = free_space - menu_item->getFont()->getWidth("...") -
+				menu_item->getNominalWidth(); // This returns width of menu item with empty label (pad pixels)
+
+			while (chars_fitted < chars_total && menu_item->getFont()->getWidth(item_name, 0, chars_fitted) < label_space)
+			{
+				chars_fitted++;
+			}
+			chars_fitted--; // Rolling back one char, that doesn't fit
+
+			menu_item->setLabel(item_name.substr(0, chars_fitted) + "...");
+		}
+
+		max_width = llmax(max_width, menu_item->getNominalWidth());
+
+		menu->addChild(menu_item);
+	}
+
+	menu->buildDrawLabels();
+	menu->updateParent(LLMenuGL::sMenuContainer);
+	menu->setButtonRect(btn_rect, this);
+	LLMenuGL::showPopup(this, menu, btn_rect.mRight, btn_rect.mTop);
+}
+
+static bool cmp_folders(const folder_pair_t& left, const folder_pair_t& right)
+{
+	return left.second < right.second;
+}
+
+static std::string getFullFolderName(const LLViewerInventoryCategory* cat)
+{
+	std::string name = cat->getName();
+	LLUUID parent_id;
+
+	// translate category name, if it's right below the root
+	// FIXME: it can throw notification about non existent string in strings.xml
+	if (cat->getParentUUID().notNull() && cat->getParentUUID() == gInventory.getRootFolderID())
+	{
+		name = LLTrans::getString("InvFolder " + name);
+	}
+
+	// we don't want "My Inventory" to appear in the name
+	while ((parent_id = cat->getParentUUID()).notNull() && parent_id != gInventory.getRootFolderID())
+	{
+		cat = gInventory.getCategory(parent_id);
+		name = cat->getName() + "/" + name;
+	}
+
+	return name;
+}
+
+static void collectLandmarkFolders(LLInventoryModel::cat_array_t& cats)
+{
+	// Add the "Landmarks" category itself.
+	LLUUID landmarks_id = gInventory.findCategoryUUIDForType(LLAssetType::AT_LANDMARK);
+	LLViewerInventoryCategory* landmarks_cat = gInventory.getCategory(landmarks_id);
+	if (!landmarks_cat)
+	{
+		llwarns << "Cannot find the landmarks folder" << llendl;
+	}
+	else
+	{
+		cats.put(landmarks_cat);
+	}
+
+	// Add descendent folders of the "Landmarks" category.
+	LLInventoryModel::item_array_t items; // unused
+	LLIsType is_category(LLAssetType::AT_CATEGORY);
+	gInventory.collectDescendentsIf(
+		landmarks_id,
+		cats,
+		items,
+		LLInventoryModel::EXCLUDE_TRASH,
+		is_category);
+
+	// Add the "My Favorites" category.
+	LLUUID favorites_id = gInventory.findCategoryUUIDForType(LLAssetType::AT_FAVORITE);
+	LLViewerInventoryCategory* favorites_cat = gInventory.getCategory(favorites_id);
+	if (!favorites_cat)
+	{
+		llwarns << "Cannot find the favorites folder" << llendl;
+	}
+	else
+	{
+		cats.put(favorites_cat);
+	}
+}
+
+const LLVector3 get_pos_local_from_global(const LLVector3d &pos_global)
+{
+	F32 region_x = (F32)fmod( pos_global.mdV[VX], (F64)REGION_WIDTH_METERS );
+	F32 region_y = (F32)fmod( pos_global.mdV[VY], (F64)REGION_WIDTH_METERS );
+
+	LLVector3 pos_local(region_x, region_y, (F32)pos_global.mdV[VZ]);
+	return pos_local;
+}