1 files changed, 431 insertions, 217 deletions

diff --git a/indra/newview/llpanelplaces.cpp b/indra/newview/llpanelplaces.cpp
index 5ab823b6e5..54455afa4f 100644
--- a/indra/newview/llpanelplaces.cpp
+++ b/indra/newview/llpanelplaces.cpp
@@ -4,7 +4,7 @@
  *
  * $LicenseInfo:firstyear=2009&license=viewergpl$
  *
- * Copyright (c) 2004-2009, Linden Research, Inc.
+ * Copyright (c) 2009, Linden Research, Inc.
  *
  * Second Life Viewer Source Code
  * The source code in this file ("Source Code") is provided by Linden Lab
@@ -34,7 +34,7 @@
 #include "llpanelplaces.h"
 
 #include "llassettype.h"
-#include "llwindow.h"
+#include "lltimer.h"
 
 #include "llinventory.h"
 #include "lllandmark.h"
@@ -43,33 +43,40 @@
 #include "llcombobox.h"
 #include "llfiltereditor.h"
 #include "llfloaterreg.h"
-#include "llnotifications.h"
+#include "llnotificationsutil.h"
 #include "lltabcontainer.h"
 #include "lltexteditor.h"
 #include "lltrans.h"
 #include "lluictrlfactory.h"
 
+#include "llwindow.h"
+
 #include "llagent.h"
 #include "llagentpicksinfo.h"
 #include "llavatarpropertiesprocessor.h"
 #include "llfloaterworldmap.h"
 #include "llinventorybridge.h"
+#include "llinventoryobserver.h"
 #include "llinventorymodel.h"
 #include "lllandmarkactions.h"
 #include "lllandmarklist.h"
-#include "llpanelplaceinfo.h"
+#include "llpanellandmarkinfo.h"
 #include "llpanellandmarks.h"
 #include "llpanelpick.h"
+#include "llpanelplaceprofile.h"
 #include "llpanelteleporthistory.h"
+#include "llremoteparcelrequest.h"
 #include "llteleporthistorystorage.h"
 #include "lltoggleablemenu.h"
 #include "llviewerinventory.h"
 #include "llviewermenu.h"
+#include "llviewermessage.h"
 #include "llviewerparcelmgr.h"
 #include "llviewerregion.h"
 #include "llviewerwindow.h"
 
 static const S32 LANDMARK_FOLDERS_MENU_WIDTH = 250;
+static const F32 PLACE_INFO_UPDATE_INTERVAL = 3.0;
 static const std::string AGENT_INFO_TYPE			= "agent";
 static const std::string CREATE_LANDMARK_INFO_TYPE	= "create_landmark";
 static const std::string LANDMARK_INFO_TYPE			= "landmark";
@@ -79,14 +86,15 @@ static const std::string TELEPORT_HISTORY_INFO_TYPE	= "teleport_history";
 // Helper functions
 static bool is_agent_in_selected_parcel(LLParcel* parcel);
 static void onSLURLBuilt(std::string& slurl);
-static void setAllChildrenVisible(LLView* view, BOOL visible);
 
 //Observer classes
 class LLPlacesParcelObserver : public LLParcelObserver
 {
 public:
-	LLPlacesParcelObserver(LLPanelPlaces* places_panel)
-	: mPlaces(places_panel) {}
+	LLPlacesParcelObserver(LLPanelPlaces* places_panel) :
+		LLParcelObserver(),
+		mPlaces(places_panel)
+	{}
 
 	/*virtual*/ void changed()
 	{
@@ -98,30 +106,98 @@ private:
 	LLPanelPlaces*		mPlaces;
 };
 
-class LLPlacesInventoryObserver : public LLInventoryObserver
+class LLPlacesInventoryObserver : public LLInventoryAddedObserver
 {
 public:
-	LLPlacesInventoryObserver(LLPanelPlaces* places_panel)
-	: mPlaces(places_panel) {}
+	LLPlacesInventoryObserver(LLPanelPlaces* places_panel) :
+		mPlaces(places_panel),
+		mTabsCreated(false)
+	{}
 
 	/*virtual*/ void changed(U32 mask)
 	{
+		LLInventoryAddedObserver::changed(mask);
+
+		if (!mTabsCreated && mPlaces)
+		{
+			mPlaces->createTabs();
+			mTabsCreated = true;
+		}
+	}
+
+protected:
+	/*virtual*/ void done()
+	{
+		mPlaces->showAddedLandmarkInfo(mAdded);
+		mAdded.clear();
+	}
+
+private:
+	LLPanelPlaces*		mPlaces;
+	bool				mTabsCreated;
+};
+
+class LLPlacesRemoteParcelInfoObserver : public LLRemoteParcelInfoObserver
+{
+public:
+	LLPlacesRemoteParcelInfoObserver(LLPanelPlaces* places_panel) :
+		LLRemoteParcelInfoObserver(),
+		mPlaces(places_panel)
+	{}
+
+	~LLPlacesRemoteParcelInfoObserver()
+	{
+		// remove any in-flight observers
+		std::set<LLUUID>::iterator it;
+		for (it = mParcelIDs.begin(); it != mParcelIDs.end(); ++it)
+		{
+			const LLUUID &id = *it;
+			LLRemoteParcelInfoProcessor::getInstance()->removeObserver(id, this);
+		}
+		mParcelIDs.clear();
+	}
+
+	/*virtual*/ void processParcelInfo(const LLParcelData& parcel_data)
+	{
 		if (mPlaces)
-			mPlaces->changedInventory(mask);
+		{
+			mPlaces->changedGlobalPos(LLVector3d(parcel_data.global_x,
+												 parcel_data.global_y,
+												 parcel_data.global_z));
+		}
+
+		mParcelIDs.erase(parcel_data.parcel_id);
+		LLRemoteParcelInfoProcessor::getInstance()->removeObserver(parcel_data.parcel_id, this);
+	}
+	/*virtual*/ void setParcelID(const LLUUID& parcel_id)
+	{
+		if (!parcel_id.isNull())
+		{
+			mParcelIDs.insert(parcel_id);
+			LLRemoteParcelInfoProcessor::getInstance()->addObserver(parcel_id, this);
+			LLRemoteParcelInfoProcessor::getInstance()->sendParcelInfoRequest(parcel_id);
+		}
+	}
+	/*virtual*/ void setErrorStatus(U32 status, const std::string& reason)
+	{
+		llerrs << "Can't complete remote parcel request. Http Status: "
+			   << status << ". Reason : " << reason << llendl;
 	}
 
 private:
+	std::set<LLUUID>	mParcelIDs;
 	LLPanelPlaces*		mPlaces;
 };
 
+
 static LLRegisterPanelClassWrapper<LLPanelPlaces> t_places("panel_places");
 
 LLPanelPlaces::LLPanelPlaces()
 	:	LLPanel(),
-		mFilterSubString(LLStringUtil::null),
 		mActivePanel(NULL),
 		mFilterEditor(NULL),
-		mPlaceInfo(NULL),
+		mPlaceProfile(NULL),
+		mLandmarkInfo(NULL),
 		mPickPanel(NULL),
 		mItem(NULL),
 		mPlaceMenu(NULL),
@@ -131,11 +207,12 @@ LLPanelPlaces::LLPanelPlaces()
 {
 	mParcelObserver = new LLPlacesParcelObserver(this);
 	mInventoryObserver = new LLPlacesInventoryObserver(this);
+	mRemoteParcelObserver = new LLPlacesRemoteParcelInfoObserver(this);
 
 	gInventory.addObserver(mInventoryObserver);
 
 	LLViewerParcelMgr::getInstance()->addAgentParcelChangedCallback(
-			boost::bind(&LLPanelPlaces::onAgentParcelChange, this));
+			boost::bind(&LLPanelPlaces::updateVerbs, this));
 
 	//LLUICtrlFactory::getInstance()->buildPanel(this, "panel_places.xml"); // Called from LLRegisterPanelClass::defaultPanelClassBuilder()
 }
@@ -149,6 +226,7 @@ LLPanelPlaces::~LLPanelPlaces()
 
 	delete mInventoryObserver;
 	delete mParcelObserver;
+	delete mRemoteParcelObserver;
 }
 
 BOOL LLPanelPlaces::postBuild()
@@ -158,9 +236,6 @@ BOOL LLPanelPlaces::postBuild()
 	
 	mShowOnMapBtn = getChild<LLButton>("map_btn");
 	mShowOnMapBtn->setClickedCallback(boost::bind(&LLPanelPlaces::onShowOnMapButtonClicked, this));
-	
-	mShareBtn = getChild<LLButton>("share_btn");
-	//mShareBtn->setClickedCallback(boost::bind(&LLPanelPlaces::onShareButtonClicked, this));
 
 	mEditBtn = getChild<LLButton>("edit_btn");
 	mEditBtn->setClickedCallback(boost::bind(&LLPanelPlaces::onEditButtonClicked, this));
@@ -203,97 +278,126 @@ BOOL LLPanelPlaces::postBuild()
 	mFilterEditor = getChild<LLFilterEditor>("Filter");
 	if (mFilterEditor)
 	{
+		//when list item is being clicked the filter editor looses focus
+		//committing on focus lost leads to detaching list items
+		//BUT a detached list item cannot be made selected and must not be clicked onto
+		mFilterEditor->setCommitOnFocusLost(false);
+
 		mFilterEditor->setCommitCallback(boost::bind(&LLPanelPlaces::onFilterEdit, this, _2, false));
 	}
 
-	mPlaceInfo = getChild<LLPanelPlaceInfo>("panel_place_info");
+	mPlaceProfile = getChild<LLPanelPlaceProfile>("panel_place_profile");
+	mLandmarkInfo = getChild<LLPanelLandmarkInfo>("panel_landmark_info");
+	if (!mPlaceProfile || !mLandmarkInfo)
+		return FALSE;
 
-	LLButton* back_btn = mPlaceInfo->getChild<LLButton>("back_btn");
-	back_btn->setClickedCallback(boost::bind(&LLPanelPlaces::onBackButtonClicked, this));
+	mPlaceProfileBackBtn = mPlaceProfile->getChild<LLButton>("back_btn");
+	mPlaceProfileBackBtn->setClickedCallback(boost::bind(&LLPanelPlaces::onBackButtonClicked, this));
 
-	LLLineEditor* title_editor = mPlaceInfo->getChild<LLLineEditor>("title_editor");
+	mLandmarkInfoBackBtn = mLandmarkInfo->getChild<LLButton>("back_btn");
+	mLandmarkInfoBackBtn->setClickedCallback(boost::bind(&LLPanelPlaces::onBackButtonClicked, this));
+
+	LLLineEditor* title_editor = mLandmarkInfo->getChild<LLLineEditor>("title_editor");
 	title_editor->setKeystrokeCallback(boost::bind(&LLPanelPlaces::onEditButtonClicked, this), NULL);
 
-	LLTextEditor* notes_editor = mPlaceInfo->getChild<LLTextEditor>("notes_editor");
+	LLTextEditor* notes_editor = mLandmarkInfo->getChild<LLTextEditor>("notes_editor");
 	notes_editor->setKeystrokeCallback(boost::bind(&LLPanelPlaces::onEditButtonClicked, this));
 
-	LLComboBox* folder_combo = mPlaceInfo->getChild<LLComboBox>("folder_combo");
-	folder_combo->setSelectionCallback(boost::bind(&LLPanelPlaces::onEditButtonClicked, this));
+	LLComboBox* folder_combo = mLandmarkInfo->getChild<LLComboBox>("folder_combo");
+	folder_combo->setCommitCallback(boost::bind(&LLPanelPlaces::onEditButtonClicked, this));
+
 	return TRUE;
 }
 
 void LLPanelPlaces::onOpen(const LLSD& key)
 {
-	if(mPlaceInfo == NULL || key.size() == 0)
+	if (!mPlaceProfile || !mLandmarkInfo)
 		return;
 
-	mFilterEditor->clear();
-	onFilterEdit("", false);
-
-	mPlaceInfoType = key["type"].asString();
-	mPosGlobal.setZero();
-	mItem = NULL;
-	isLandmarkEditModeOn = false;
-	togglePlaceInfoPanel(TRUE);
-	updateVerbs();
-
-	if (mPlaceInfoType == AGENT_INFO_TYPE)
+	if (key.size() != 0)
 	{
-		mPlaceInfo->setInfoType(LLPanelPlaceInfo::AGENT);
-	}
-	else if (mPlaceInfoType == CREATE_LANDMARK_INFO_TYPE)
-	{
-		mPlaceInfo->setInfoType(LLPanelPlaceInfo::CREATE_LANDMARK);
+		mFilterEditor->clear();
+		onFilterEdit("", false);
 
-		if (key.has("x") && key.has("y") && key.has("z"))
+		mPlaceInfoType = key["type"].asString();
+		mPosGlobal.setZero();
+		mItem = NULL;
+		isLandmarkEditModeOn = false;
+		togglePlaceInfoPanel(TRUE);
+
+		if (mPlaceInfoType == AGENT_INFO_TYPE)
 		{
-			mPosGlobal = LLVector3d(key["x"].asReal(),
-									key["y"].asReal(),
-									key["z"].asReal());
+			mPlaceProfile->setInfoType(LLPanelPlaceInfo::AGENT);
 		}
-		else
+		else if (mPlaceInfoType == CREATE_LANDMARK_INFO_TYPE)
 		{
-			mPosGlobal = gAgent.getPositionGlobal();
-		}
+			mLandmarkInfo->setInfoType(LLPanelPlaceInfo::CREATE_LANDMARK);
 
-		mPlaceInfo->displayParcelInfo(LLUUID(), mPosGlobal);
-	}
-	else if (mPlaceInfoType == LANDMARK_INFO_TYPE)
-	{
-		mPlaceInfo->setInfoType(LLPanelPlaceInfo::LANDMARK);
+			if (key.has("x") && key.has("y") && key.has("z"))
+			{
+				mPosGlobal = LLVector3d(key["x"].asReal(),
+										key["y"].asReal(),
+										key["z"].asReal());
+			}
+			else
+			{
+				mPosGlobal = gAgent.getPositionGlobal();
+			}
 
-		LLInventoryItem* item = gInventory.getItem(key["id"].asUUID());
-		if (!item)
-			return;
+			mLandmarkInfo->displayParcelInfo(LLUUID(), mPosGlobal);
 
-		setItem(item);
-	}
-	else if (mPlaceInfoType == REMOTE_PLACE_INFO_TYPE)
-	{
-		if (mPlaceInfo->isMediaPanelVisible())
+			// Disabling "Save", "Close" and "Back" buttons to prevent closing "Create Landmark"
+			// panel before created landmark is loaded.
+			// These buttons will be enabled when created landmark is added to inventory.
+			mSaveBtn->setEnabled(FALSE);
+			mCloseBtn->setEnabled(FALSE);
+			mLandmarkInfoBackBtn->setEnabled(FALSE);
+		}
+		else if (mPlaceInfoType == LANDMARK_INFO_TYPE)
 		{
-			toggleMediaPanel();
+			mLandmarkInfo->setInfoType(LLPanelPlaceInfo::LANDMARK);
+
+			LLInventoryItem* item = gInventory.getItem(key["id"].asUUID());
+			if (!item)
+				return;
+
+			setItem(item);
 		}
+		else if (mPlaceInfoType == REMOTE_PLACE_INFO_TYPE)
+		{
+			if (key.has("id"))
+			{
+				LLUUID parcel_id = key["id"].asUUID();
+				mPlaceProfile->setParcelID(parcel_id);
 
-		mPosGlobal = LLVector3d(key["x"].asReal(),
-								key["y"].asReal(),
-								key["z"].asReal());
+				// query the server to get the global 3D position of this
+				// parcel - we need this for teleport/mapping functions.
+				mRemoteParcelObserver->setParcelID(parcel_id);
+			}
+			else
+			{
+				mPosGlobal = LLVector3d(key["x"].asReal(),
+										key["y"].asReal(),
+										key["z"].asReal());
+				mPlaceProfile->displayParcelInfo(LLUUID(), mPosGlobal);
+			}
 
-		mPlaceInfo->setInfoType(LLPanelPlaceInfo::PLACE);
-		mPlaceInfo->displayParcelInfo(LLUUID(), mPosGlobal);
-	}
-	else if (mPlaceInfoType == TELEPORT_HISTORY_INFO_TYPE)
-	{
-		S32 index = key["id"].asInteger();
+			mPlaceProfile->setInfoType(LLPanelPlaceInfo::PLACE);
+		}
+		else if (mPlaceInfoType == TELEPORT_HISTORY_INFO_TYPE)
+		{
+			S32 index = key["id"].asInteger();
 
-		const LLTeleportHistoryStorage::slurl_list_t& hist_items =
-					LLTeleportHistoryStorage::getInstance()->getItems();
+			const LLTeleportHistoryStorage::slurl_list_t& hist_items =
+						LLTeleportHistoryStorage::getInstance()->getItems();
 
-		mPosGlobal = hist_items[index].mGlobalPos;
+			mPosGlobal = hist_items[index].mGlobalPos;
 
-		mPlaceInfo->setInfoType(LLPanelPlaceInfo::TELEPORT_HISTORY);
-		mPlaceInfo->updateLastVisitedText(hist_items[index].mDate);
-		mPlaceInfo->displayParcelInfo(LLUUID(), mPosGlobal);
+			mPlaceProfile->setInfoType(LLPanelPlaceInfo::TELEPORT_HISTORY);
+			mPlaceProfile->displayParcelInfo(LLUUID(), mPosGlobal);
+		}
+
+		updateVerbs();
 	}
 
 	LLViewerParcelMgr* parcel_mgr = LLViewerParcelMgr::getInstance();
@@ -305,6 +409,10 @@ void LLPanelPlaces::onOpen(const LLSD& key)
 	// Otherwise stop using land selection and deselect land.
 	if (mPlaceInfoType == AGENT_INFO_TYPE)
 	{
+		// We don't know if we are already added to LLViewerParcelMgr observers list
+		// so try to remove observer not to add an extra one.
+		parcel_mgr->removeObserver(mParcelObserver);
+
 		parcel_mgr->addObserver(mParcelObserver);
 		parcel_mgr->selectParcelAt(gAgent.getPositionGlobal());
 	}
@@ -312,16 +420,19 @@ void LLPanelPlaces::onOpen(const LLSD& key)
 	{
 		parcel_mgr->removeObserver(mParcelObserver);
 
+		// Clear the reference to selection to allow its removal in deselectUnused().
+		mParcel.clear();
+
 		if (!parcel_mgr->selectionEmpty())
 		{
-			parcel_mgr->deselectLand();
+			parcel_mgr->deselectUnused();
 		}
 	}
 }
 
 void LLPanelPlaces::setItem(LLInventoryItem* item)
 {
-	if (!mPlaceInfo || !item)
+	if (!mLandmarkInfo || !item)
 		return;
 
 	mItem = item;
@@ -348,13 +459,24 @@ void LLPanelPlaces::setItem(LLInventoryItem* item)
 
 	mEditBtn->setEnabled(is_landmark_editable);
 	mSaveBtn->setEnabled(is_landmark_editable);
+	mCloseBtn->setEnabled(TRUE);
+	mLandmarkInfoBackBtn->setEnabled(TRUE);
 
 	if (is_landmark_editable)
 	{
-		mPlaceInfo->setLandmarkFolder(mItem->getParentUUID());
+		if(!mLandmarkInfo->setLandmarkFolder(mItem->getParentUUID()) && !mItem->getParentUUID().isNull())
+		{
+			const LLViewerInventoryCategory* cat = gInventory.getCategory(mItem->getParentUUID());
+			if (cat)
+			{
+				std::string cat_fullname = LLPanelLandmarkInfo::getFullFolderName(cat);
+				LLComboBox* folderList = mLandmarkInfo->getChild<LLComboBox>("folder_combo");
+				folderList->add(cat_fullname, cat->getUUID(), ADD_TOP);
+			}
+		}
 	}
 
-	mPlaceInfo->displayItemInfo(mItem);
+	mLandmarkInfo->displayItemInfo(mItem);
 
 	LLLandmark* lm = gLandmarkList.getAsset(mItem->getAssetUUID(),
 											boost::bind(&LLPanelPlaces::onLandmarkLoaded, this, _1));
@@ -364,29 +486,49 @@ void LLPanelPlaces::setItem(LLInventoryItem* item)
 	}
 }
 
+S32 LLPanelPlaces::notifyParent(const LLSD& info)
+{
+	if(info.has("update_verbs"))
+	{
+		if(mPosGlobal.isExactlyZero())
+		{
+			mPosGlobal.setVec(info["global_x"], info["global_y"], info["global_z"]);
+		}
+
+		updateVerbs();
+		
+		return 1;
+	}
+	return LLPanel::notifyParent(info);
+}
+
 void LLPanelPlaces::onLandmarkLoaded(LLLandmark* landmark)
 {
-	if (!mPlaceInfo)
+	if (!mLandmarkInfo)
 		return;
 
 	LLUUID region_id;
 	landmark->getRegionID(region_id);
 	landmark->getGlobalPos(mPosGlobal);
-	mPlaceInfo->displayParcelInfo(region_id, mPosGlobal);
+	mLandmarkInfo->displayParcelInfo(region_id, mPosGlobal);
+
+	updateVerbs();
 }
 
 void LLPanelPlaces::onFilterEdit(const std::string& search_string, bool force_filter)
 {
-	if (force_filter || mFilterSubString != search_string)
+	if (!mActivePanel)
+		return;
+
+	if (force_filter || mActivePanel->getFilterSubString() != search_string)
 	{
-		mFilterSubString = search_string;
+		std::string string = search_string;
 
 		// Searches are case-insensitive
-		LLStringUtil::toUpper(mFilterSubString);
-		LLStringUtil::trimHead(mFilterSubString);
+		LLStringUtil::toUpper(string);
+		LLStringUtil::trimHead(string);
 
-		if (mActivePanel)
-			mActivePanel->onSearchEdit(mFilterSubString);
+		mActivePanel->onSearchEdit(string);
 	}
 }
 
@@ -396,29 +538,22 @@ void LLPanelPlaces::onTabSelected()
 	if (!mActivePanel)
 		return;
 
-	onFilterEdit(mFilterSubString, true);
+	onFilterEdit(mActivePanel->getFilterSubString(), true);
 	mActivePanel->updateVerbs();
 }
 
-/*
-void LLPanelPlaces::onShareButtonClicked()
-{
-	// TODO: Launch the "Things" Share wizard
-}
-*/
-
 void LLPanelPlaces::onTeleportButtonClicked()
 {
-	if (!mPlaceInfo)
-		return;
-
-	if (mPlaceInfo->getVisible())
+	LLPanelPlaceInfo* panel = getCurrentInfoPanel();
+	if (panel && panel->getVisible())
 	{
 		if (mPlaceInfoType == LANDMARK_INFO_TYPE)
 		{
 			LLSD payload;
 			payload["asset_id"] = mItem->getAssetUUID();
-			LLNotifications::instance().add("TeleportFromLandmark", LLSD(), payload);
+			LLSD args; 
+			args["LOCATION"] = mItem->getName(); 
+			LLNotificationsUtil::add("TeleportFromLandmark", args, payload);
 		}
 		else if (mPlaceInfoType == AGENT_INFO_TYPE ||
 				 mPlaceInfoType == REMOTE_PLACE_INFO_TYPE ||
@@ -441,10 +576,8 @@ void LLPanelPlaces::onTeleportButtonClicked()
 
 void LLPanelPlaces::onShowOnMapButtonClicked()
 {
-	if (!mPlaceInfo)
-		return;
-
-	if (mPlaceInfo->getVisible())
+	LLPanelPlaceInfo* panel = getCurrentInfoPanel();
+	if (panel && panel->getVisible())
 	{
 		LLFloaterWorldMap* worldmap_instance = LLFloaterWorldMap::getInstance();
 		if(!worldmap_instance)
@@ -487,31 +620,31 @@ void LLPanelPlaces::onShowOnMapButtonClicked()
 
 void LLPanelPlaces::onEditButtonClicked()
 {
-	if (!mPlaceInfo || isLandmarkEditModeOn)
+	if (!mLandmarkInfo || isLandmarkEditModeOn)
 		return;
 
 	isLandmarkEditModeOn = true;
 
-	mPlaceInfo->toggleLandmarkEditMode(TRUE);
+	mLandmarkInfo->toggleLandmarkEditMode(TRUE);
 
 	updateVerbs();
 }
 
 void LLPanelPlaces::onSaveButtonClicked()
 {
-	if (!mPlaceInfo || mItem.isNull())
+	if (!mLandmarkInfo || mItem.isNull())
 		return;
 
-	std::string current_title_value = mPlaceInfo->getLandmarkTitle();
+	std::string current_title_value = mLandmarkInfo->getLandmarkTitle();
 	std::string item_title_value = mItem->getName();
-	std::string current_notes_value = mPlaceInfo->getLandmarkNotes();
+	std::string current_notes_value = mLandmarkInfo->getLandmarkNotes();
 	std::string item_notes_value = mItem->getDescription();
 
 	LLStringUtil::trim(current_title_value);
 	LLStringUtil::trim(current_notes_value);
 
 	LLUUID item_id = mItem->getUUID();
-	LLUUID folder_id = mPlaceInfo->getLandmarkFolder();
+	LLUUID folder_id = mLandmarkInfo->getLandmarkFolder();
 
 	LLPointer<LLViewerInventoryItem> new_item = new LLViewerInventoryItem(mItem);
 
@@ -544,7 +677,7 @@ void LLPanelPlaces::onSaveButtonClicked()
 
 void LLPanelPlaces::onCancelButtonClicked()
 {
-	if (!mPlaceInfo)
+	if (!mLandmarkInfo)
 		return;
 
 	if (mPlaceInfoType == CREATE_LANDMARK_INFO_TYPE)
@@ -553,13 +686,13 @@ void LLPanelPlaces::onCancelButtonClicked()
 	}
 	else
 	{
-		mPlaceInfo->toggleLandmarkEditMode(FALSE);
+		mLandmarkInfo->toggleLandmarkEditMode(FALSE);
 		isLandmarkEditModeOn = false;
 
 		updateVerbs();
 
 		// Reload the landmark properties.
-		mPlaceInfo->displayItemInfo(mItem);
+		mLandmarkInfo->displayItemInfo(mItem);
 	}
 }
 
@@ -588,7 +721,7 @@ void LLPanelPlaces::onOverflowButtonClicked()
 		if (mItem.notNull())
 		{
 			const LLUUID& item_id = mItem->getUUID();
-			const LLUUID& trash_id = gInventory.findCategoryUUIDForType(LLAssetType::AT_TRASH);
+			const LLUUID trash_id = gInventory.findCategoryUUIDForType(LLFolderType::FT_TRASH);
 			is_landmark_removable = gInventory.isObjectDescendentOf(item_id, gInventory.getRootFolderID()) &&
 									!gInventory.isObjectDescendentOf(item_id, trash_id);
 		}
@@ -603,9 +736,12 @@ void LLPanelPlaces::onOverflowButtonClicked()
 	if (!menu->toggleVisibility())
 		return;
 
+	if (menu->getButtonRect().isEmpty())
+	{
+		menu->setButtonRect(mOverflowBtn);
+	}
 	menu->updateParent(LLMenuGL::sMenuContainer);
 	LLRect rect = mOverflowBtn->getRect();
-	menu->setButtonRect(rect, this);
 	LLMenuGL::showPopup(this, menu, rect.mRight, rect.mTop);
 }
 
@@ -643,9 +779,6 @@ void LLPanelPlaces::onOverflowMenuItemClicked(const LLSD& param)
 	}
 	else if (item == "pick")
 	{
-		if (!mPlaceInfo)
-			return;
-
 		if (mPickPanel == NULL)
 		{
 			mPickPanel = LLPanelPickEdit::create();
@@ -658,96 +791,139 @@ void LLPanelPlaces::onOverflowMenuItemClicked(const LLSD& param)
 
 		togglePickPanel(TRUE);
 		mPickPanel->onOpen(LLSD());
-		mPlaceInfo->createPick(mPosGlobal, mPickPanel);
+
+		LLPanelPlaceInfo* panel = getCurrentInfoPanel();
+		if (panel)
+		{
+			panel->createPick(mPosGlobal, mPickPanel);
+		}
 
 		LLRect rect = getRect();
 		mPickPanel->reshape(rect.getWidth(), rect.getHeight());
 		mPickPanel->setRect(rect);
 	}
-    else if (item == "add_to_favbar")
-    {
-        if ( mItem.notNull() ) 
-        {
-            LLUUID favorites_id = gInventory.findCategoryUUIDForType(LLAssetType::AT_FAVORITE);
-            if ( favorites_id.notNull() )
-            {
-                copy_inventory_item(gAgent.getID(),
-                                    mItem->getPermissions().getOwner(),
-                                    mItem->getUUID(),
-                                    favorites_id,
-                                    std::string(),
-                                    LLPointer<LLInventoryCallback>(NULL));
-                llinfos << "Copied inventory item #" << mItem->getUUID() << " to favorites." << llendl;
-            }
-        }
-    }
+	else if (item == "add_to_favbar")
+	{
+		if ( mItem.notNull() )
+		{
+			const LLUUID& favorites_id = gInventory.findCategoryUUIDForType(LLFolderType::FT_FAVORITE);
+			if ( favorites_id.notNull() )
+			{
+				copy_inventory_item(gAgent.getID(),
+									mItem->getPermissions().getOwner(),
+									mItem->getUUID(),
+									favorites_id,
+									std::string(),
+									LLPointer<LLInventoryCallback>(NULL));
+				llinfos << "Copied inventory item #" << mItem->getUUID() << " to favorites." << llendl;
+			}
+		}
+	}
 }
 
 void LLPanelPlaces::onBackButtonClicked()
 {
-	if (!mPlaceInfo)
-		return;
-	
-	if (mPlaceInfo->isMediaPanelVisible())
-	{
-		toggleMediaPanel();
-	}
-	else
-	{
-		togglePlaceInfoPanel(FALSE);
+	togglePlaceInfoPanel(FALSE);
 
-		// Resetting mPlaceInfoType when Place Info panel is closed.
-		mPlaceInfoType = LLStringUtil::null;
+	// Resetting mPlaceInfoType when Place Info panel is closed.
+	mPlaceInfoType = LLStringUtil::null;
 
-		isLandmarkEditModeOn = false;
-	}
+	isLandmarkEditModeOn = false;
 
 	updateVerbs();
 }
 
-void LLPanelPlaces::toggleMediaPanel()
-{
-	if (!mPlaceInfo)
-		return;
-
-	mPlaceInfo->toggleMediaPanel(!mPlaceInfo->isMediaPanelVisible());
-
-	// Refresh the current place info because
-	// the media panel controls can't refer to
-	// the remote parcel media.
-	onOpen(LLSD().insert("type", AGENT_INFO_TYPE));
-}
-
 void LLPanelPlaces::togglePickPanel(BOOL visible)
 {
-	setAllChildrenVisible(this, !visible);
-
 	if (mPickPanel)
 		mPickPanel->setVisible(visible);
 }
 
 void LLPanelPlaces::togglePlaceInfoPanel(BOOL visible)
 {
-	if (!mPlaceInfo)
+	if (!mPlaceProfile || !mLandmarkInfo)
 		return;
 
-	mPlaceInfo->setVisible(visible);
 	mFilterEditor->setVisible(!visible);
 	mTabContainer->setVisible(!visible);
 
-	if (visible)
+	if (mPlaceInfoType == AGENT_INFO_TYPE ||
+		mPlaceInfoType == REMOTE_PLACE_INFO_TYPE ||
+		mPlaceInfoType == TELEPORT_HISTORY_INFO_TYPE)
 	{
-		mPlaceInfo->resetLocation();
+		mPlaceProfile->setVisible(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());
+		if (visible)
+		{
+			mPlaceProfile->resetLocation();
+
+			// Do not reset location info until mResetInfoTimer has expired
+			// to avoid text blinking.
+			mResetInfoTimer.setTimerExpirySec(PLACE_INFO_UPDATE_INTERVAL);
+
+			LLRect rect = getRect();
+			LLRect new_rect = LLRect(rect.mLeft, rect.mTop, rect.mRight, mTabContainer->getRect().mBottom);
+			mPlaceProfile->reshape(new_rect.getWidth(), new_rect.getHeight());
+
+			mLandmarkInfo->setVisible(FALSE);
+		}
+		else if (mPlaceInfoType == AGENT_INFO_TYPE)
+		{
+			LLViewerParcelMgr::getInstance()->removeObserver(mParcelObserver);
+
+			// Clear reference to parcel selection when closing place profile panel.
+			// LLViewerParcelMgr removes the selection if it has 1 reference to it.
+			mParcel.clear();
+		}
+	}
+	else if (mPlaceInfoType == CREATE_LANDMARK_INFO_TYPE ||
+			 mPlaceInfoType == LANDMARK_INFO_TYPE)
+	{
+		mLandmarkInfo->setVisible(visible);
+
+		if (visible)
+		{
+			mLandmarkInfo->resetLocation();
+
+			LLRect rect = getRect();
+			LLRect new_rect = LLRect(rect.mLeft, rect.mTop, rect.mRight, mTabContainer->getRect().mBottom);
+			mLandmarkInfo->reshape(new_rect.getWidth(), new_rect.getHeight());
+
+			mPlaceProfile->setVisible(FALSE);
+		}
+		else
+		{
+			LLLandmarksPanel* landmarks_panel =
+					dynamic_cast<LLLandmarksPanel*>(mTabContainer->getPanelByName("Landmarks"));
+			if (landmarks_panel && mItem.notNull())
+			{
+				// If a landmark info is being closed we open the landmarks tab
+				// and set this landmark selected.
+				mTabContainer->selectTabPanel(landmarks_panel);
+
+				landmarks_panel->setItemSelected(mItem->getUUID(), TRUE);
+			}
+		}
+	}
+}
+
+// virtual
+void LLPanelPlaces::handleVisibilityChange(BOOL new_visibility)
+{
+	LLPanel::handleVisibilityChange(new_visibility);
+
+	if (!new_visibility && mPlaceInfoType == AGENT_INFO_TYPE)
+	{
+		LLViewerParcelMgr::getInstance()->removeObserver(mParcelObserver);
+
+		// Clear reference to parcel selection when closing places panel.
+		mParcel.clear();
 	}
 }
 
 void LLPanelPlaces::changedParcelSelection()
 {
-	if (!mPlaceInfo)
+	if (!mPlaceProfile)
 		return;
 
 	LLViewerParcelMgr* parcel_mgr = LLViewerParcelMgr::getInstance();
@@ -757,6 +933,8 @@ void LLPanelPlaces::changedParcelSelection()
 	if (!region || !parcel)
 		return;
 
+	LLVector3d prev_pos_global = mPosGlobal;
+
 	// If agent is inside the selected parcel show agent's region<X, Y, Z>,
 	// otherwise show region<X, Y, Z> of agent's selection point.
 	bool is_current_parcel = is_agent_in_selected_parcel(parcel);
@@ -773,13 +951,20 @@ void LLPanelPlaces::changedParcelSelection()
 		}
 	}
 
-	mPlaceInfo->resetLocation();
-	mPlaceInfo->displaySelectedParcelInfo(parcel, region, mPosGlobal, is_current_parcel);
+	// Reset location info only if global position has changed
+	// and update timer has expired to reduce unnecessary text and icons updates.
+	if (prev_pos_global != mPosGlobal && mResetInfoTimer.hasExpired())
+	{
+		mPlaceProfile->resetLocation();
+		mResetInfoTimer.setTimerExpirySec(PLACE_INFO_UPDATE_INTERVAL);
+	}
+
+	mPlaceProfile->displaySelectedParcelInfo(parcel, region, mPosGlobal, is_current_parcel);
 
 	updateVerbs();
 }
 
-void LLPanelPlaces::changedInventory(U32 mask)
+void LLPanelPlaces::createTabs()
 {
 	if (!(gInventory.isInventoryUsable() && LLTeleportHistory::getInstance()))
 		return;
@@ -814,48 +999,69 @@ void LLPanelPlaces::changedInventory(U32 mask)
 
 	// Filter applied to show all items.
 	if (mActivePanel)
-		mActivePanel->onSearchEdit(mFilterSubString);
-
-	// we don't need to monitor inventory changes anymore,
-	// so remove the observer
-	gInventory.removeObserver(mInventoryObserver);
+		mActivePanel->onSearchEdit(mActivePanel->getFilterSubString());
 }
 
-void LLPanelPlaces::onAgentParcelChange()
+void LLPanelPlaces::changedGlobalPos(const LLVector3d &global_pos)
 {
-	if (!mPlaceInfo)
-		return;
+	mPosGlobal = global_pos;
+	updateVerbs();
+}
 
-	if (mPlaceInfo->isMediaPanelVisible())
-	{
-		onOpen(LLSD().insert("type", AGENT_INFO_TYPE));
-	}
-	else
+void LLPanelPlaces::showAddedLandmarkInfo(const uuid_vec_t& items)
+{
+	for (uuid_vec_t::const_iterator item_iter = items.begin();
+		 item_iter != items.end();
+		 ++item_iter)
 	{
-		updateVerbs();
+		const LLUUID& item_id = (*item_iter);
+		if(!highlight_offered_item(item_id))
+		{
+			continue;
+		}
+
+		LLInventoryItem* item = gInventory.getItem(item_id);
+
+		llassert(item);
+		if (item && (LLAssetType::AT_LANDMARK == item->getType()) )
+		{
+			// Created landmark is passed to Places panel to allow its editing.
+			// If the panel is closed we don't reopen it until created landmark is loaded.
+			if("create_landmark" == getPlaceInfoType() && !getItem())
+			{
+				setItem(item);
+			}
+		}
 	}
 }
 
 void LLPanelPlaces::updateVerbs()
 {
-	if (!mPlaceInfo)
-		return;
+	bool is_place_info_visible;
+
+	LLPanelPlaceInfo* panel = getCurrentInfoPanel();
+	if (panel)
+	{
+		is_place_info_visible = panel->getVisible();
+	}
+	else
+	{
+		is_place_info_visible = false;
+	}
 
-	bool is_place_info_visible = mPlaceInfo->getVisible();
 	bool is_agent_place_info_visible = mPlaceInfoType == AGENT_INFO_TYPE;
 	bool is_create_landmark_visible = mPlaceInfoType == CREATE_LANDMARK_INFO_TYPE;
-	bool is_media_panel_visible = mPlaceInfo->isMediaPanelVisible();
+	bool have_3d_pos = ! mPosGlobal.isExactlyZero();
 
 	mTeleportBtn->setVisible(!is_create_landmark_visible && !isLandmarkEditModeOn);
 	mShowOnMapBtn->setVisible(!is_create_landmark_visible && !isLandmarkEditModeOn);
-	mShareBtn->setVisible(!is_create_landmark_visible && !isLandmarkEditModeOn);
-	mOverflowBtn->setVisible(!is_create_landmark_visible && !isLandmarkEditModeOn);
+	mOverflowBtn->setVisible(is_place_info_visible && !is_create_landmark_visible && !isLandmarkEditModeOn);
 	mEditBtn->setVisible(mPlaceInfoType == LANDMARK_INFO_TYPE && !isLandmarkEditModeOn);
 	mSaveBtn->setVisible(isLandmarkEditModeOn);
 	mCancelBtn->setVisible(isLandmarkEditModeOn);
 	mCloseBtn->setVisible(is_create_landmark_visible && !isLandmarkEditModeOn);
 
-	mOverflowBtn->setEnabled(is_place_info_visible && !is_media_panel_visible && !is_create_landmark_visible);
+	mShowOnMapBtn->setEnabled(!is_create_landmark_visible && !isLandmarkEditModeOn && have_3d_pos);
 
 	if (is_place_info_visible)
 	{
@@ -863,16 +1069,20 @@ void LLPanelPlaces::updateVerbs()
 		{
 			// We don't need to teleport to the current location
 			// so check if the location is not within the current parcel.
-			mTeleportBtn->setEnabled(!is_media_panel_visible &&
-									 !mPosGlobal.isExactlyZero() &&
+			mTeleportBtn->setEnabled(have_3d_pos &&
 									 !LLViewerParcelMgr::getInstance()->inAgentParcel(mPosGlobal));
 		}
 		else if (mPlaceInfoType == LANDMARK_INFO_TYPE || mPlaceInfoType == REMOTE_PLACE_INFO_TYPE)
 		{
-			mTeleportBtn->setEnabled(TRUE);
+			mTeleportBtn->setEnabled(have_3d_pos);
 		}
 
-		mShowOnMapBtn->setEnabled(!is_media_panel_visible);
+		// Do not enable landmark info Back button when we are waiting
+		// for newly created landmark to load.
+		if (!is_create_landmark_visible)
+		{
+			mLandmarkInfoBackBtn->setEnabled(TRUE);
+		}
 	}
 	else
 	{
@@ -881,6 +1091,23 @@ void LLPanelPlaces::updateVerbs()
 	}
 }
 
+LLPanelPlaceInfo* LLPanelPlaces::getCurrentInfoPanel()
+{
+	if (mPlaceInfoType == AGENT_INFO_TYPE ||
+		mPlaceInfoType == REMOTE_PLACE_INFO_TYPE ||
+		mPlaceInfoType == TELEPORT_HISTORY_INFO_TYPE)
+	{
+		return mPlaceProfile;
+	}
+	else if (mPlaceInfoType == CREATE_LANDMARK_INFO_TYPE ||
+			 mPlaceInfoType == LANDMARK_INFO_TYPE)
+	{
+		return mLandmarkInfo;
+	}
+
+	return NULL;
+}
+
 static bool is_agent_in_selected_parcel(LLParcel* parcel)
 {
 	LLViewerParcelMgr* parcel_mgr = LLViewerParcelMgr::getInstance();
@@ -900,18 +1127,5 @@ static void onSLURLBuilt(std::string& slurl)
 	LLSD args;
 	args["SLURL"] = slurl;
 
-	LLNotifications::instance().add("CopySLURL", args);
-}
-
-static void setAllChildrenVisible(LLView* view, BOOL visible)
-{
-	const LLView::child_list_t* children = view->getChildList();
-	for (LLView::child_list_const_iter_t child_it = children->begin(); child_it != children->end(); ++child_it)
-	{
-		LLView* child = *child_it;
-		if (child->getParent() == view)
-		{
-			child->setVisible(visible);
-		}
-	}
+	LLNotificationsUtil::add("CopySLURL", args);
 }