#824 Process source files in bulk: replace tabs with spaces, convert CRLF to LF, and trim trailing whitespaces as needed

1 files changed, 248 insertions, 248 deletions

diff --git a/indra/newview/lllandmarkactions.cpp b/indra/newview/lllandmarkactions.cpp
index a17dc674ac..a5f53900ff 100644
--- a/indra/newview/lllandmarkactions.cpp
+++ b/indra/newview/lllandmarkactions.cpp
@@ -1,25 +1,25 @@
-/** 
+/**
 * @file lllandmarkactions.cpp
 * @brief LLLandmarkActions class implementation
 *
 * $LicenseInfo:firstyear=2001&license=viewerlgpl$
 * Second Life Viewer Source Code
 * Copyright (C) 2010, Linden Research, Inc.
-* 
+*
 * This library is free software; you can redistribute it and/or
 * modify it under the terms of the GNU Lesser General Public
 * License as published by the Free Software Foundation;
 * version 2.1 of the License only.
-* 
+*
 * This library is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * Lesser General Public License for more details.
-* 
+*
 * You should have received a copy of the GNU Lesser General Public
 * License along with this library; if not, write to the Free Software
 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
-* 
+*
 * Linden Research, Inc., 945 Battery Street, San Francisco, CA  94111  USA
 * $/LicenseInfo$
 */
@@ -55,344 +55,344 @@ void copy_slurl_to_clipboard_callback(const std::string& slurl);
 class LLFetchlLandmarkByPos : public LLInventoryCollectFunctor
 {
 private:
-	LLVector3d mPos;
+    LLVector3d mPos;
 public:
-	LLFetchlLandmarkByPos(const LLVector3d& pos) :
-		mPos(pos)
-	{}
-
-	/*virtual*/ bool operator()(LLInventoryCategory* cat, LLInventoryItem* item)
-	{
-		if (!item || item->getType() != LLAssetType::AT_LANDMARK)
-			return false;
-
-		LLLandmark* landmark = gLandmarkList.getAsset(item->getAssetUUID());
-		if (!landmark) // the landmark not been loaded yet
-			return false;
-
-		LLVector3d landmark_global_pos;
-		if (!landmark->getGlobalPos(landmark_global_pos))
-			return false;
-		//we have to round off each coordinates to compare positions properly
-		return ll_round(mPos.mdV[VX]) ==  ll_round(landmark_global_pos.mdV[VX])
-				&& ll_round(mPos.mdV[VY]) ==  ll_round(landmark_global_pos.mdV[VY])
-				&& ll_round(mPos.mdV[VZ]) ==  ll_round(landmark_global_pos.mdV[VZ]);
-	}
+    LLFetchlLandmarkByPos(const LLVector3d& pos) :
+        mPos(pos)
+    {}
+
+    /*virtual*/ bool operator()(LLInventoryCategory* cat, LLInventoryItem* item)
+    {
+        if (!item || item->getType() != LLAssetType::AT_LANDMARK)
+            return false;
+
+        LLLandmark* landmark = gLandmarkList.getAsset(item->getAssetUUID());
+        if (!landmark) // the landmark not been loaded yet
+            return false;
+
+        LLVector3d landmark_global_pos;
+        if (!landmark->getGlobalPos(landmark_global_pos))
+            return false;
+        //we have to round off each coordinates to compare positions properly
+        return ll_round(mPos.mdV[VX]) ==  ll_round(landmark_global_pos.mdV[VX])
+                && ll_round(mPos.mdV[VY]) ==  ll_round(landmark_global_pos.mdV[VY])
+                && ll_round(mPos.mdV[VZ]) ==  ll_round(landmark_global_pos.mdV[VZ]);
+    }
 };
 
 class LLFetchLandmarksByName : public LLInventoryCollectFunctor
 {
 private:
-	std::string name;
-	BOOL use_substring;
-	//this member will be contain copy of founded items to keep the result unique
-	std::set<std::string> check_duplicate;
+    std::string name;
+    BOOL use_substring;
+    //this member will be contain copy of founded items to keep the result unique
+    std::set<std::string> check_duplicate;
 
 public:
 LLFetchLandmarksByName(std::string &landmark_name, BOOL if_use_substring)
 :name(landmark_name),
 use_substring(if_use_substring)
-	{
-	LLStringUtil::toLower(name);
-	}
+    {
+    LLStringUtil::toLower(name);
+    }
 
 public:
-	/*virtual*/ bool operator()(LLInventoryCategory* cat, LLInventoryItem* item)
-	{
-		if (!item || item->getType() != LLAssetType::AT_LANDMARK)
-			return false;
-
-		LLLandmark* landmark = gLandmarkList.getAsset(item->getAssetUUID());
-		if (!landmark) // the landmark not been loaded yet
-			return false;
-
-		bool acceptable = false;
-		std::string landmark_name = item->getName();
-		LLStringUtil::toLower(landmark_name);
-		if(use_substring)
-		{
-			acceptable =  landmark_name.find( name ) != std::string::npos;
-		}
-		else
-		{
-			acceptable = landmark_name == name;
-		}
-		if(acceptable){
-			if(check_duplicate.find(landmark_name) != check_duplicate.end()){
-				// we have duplicated items in landmarks
-				acceptable = false;
-			}else{
-				check_duplicate.insert(landmark_name);
-			}
-		}
-
-		return acceptable;
-	}
+    /*virtual*/ bool operator()(LLInventoryCategory* cat, LLInventoryItem* item)
+    {
+        if (!item || item->getType() != LLAssetType::AT_LANDMARK)
+            return false;
+
+        LLLandmark* landmark = gLandmarkList.getAsset(item->getAssetUUID());
+        if (!landmark) // the landmark not been loaded yet
+            return false;
+
+        bool acceptable = false;
+        std::string landmark_name = item->getName();
+        LLStringUtil::toLower(landmark_name);
+        if(use_substring)
+        {
+            acceptable =  landmark_name.find( name ) != std::string::npos;
+        }
+        else
+        {
+            acceptable = landmark_name == name;
+        }
+        if(acceptable){
+            if(check_duplicate.find(landmark_name) != check_duplicate.end()){
+                // we have duplicated items in landmarks
+                acceptable = false;
+            }else{
+                check_duplicate.insert(landmark_name);
+            }
+        }
+
+        return acceptable;
+    }
 };
 
 // Returns true if the given inventory item is a landmark pointing to the current parcel.
 // Used to find out if there is at least one landmark from current parcel.
 class LLFirstAgentParcelLandmark : public LLInventoryCollectFunctor
 {
-private:	
-	bool mFounded;// to avoid unnecessary  check
-	
+private:
+    bool mFounded;// to avoid unnecessary  check
+
 public:
-	LLFirstAgentParcelLandmark(): mFounded(false){}
-	
-	/*virtual*/ bool operator()(LLInventoryCategory* cat, LLInventoryItem* item)
-	{
-		if (mFounded || !item || item->getType() != LLAssetType::AT_LANDMARK)
-			return false;
-
-		LLLandmark* landmark = gLandmarkList.getAsset(item->getAssetUUID());
-		if (!landmark) // the landmark not been loaded yet
-			return false;
-
-		LLVector3d landmark_global_pos;
-		if (!landmark->getGlobalPos(landmark_global_pos))
-			return false;
-		mFounded = LLViewerParcelMgr::getInstance()->inAgentParcel(landmark_global_pos);
-		return mFounded;
-	}
+    LLFirstAgentParcelLandmark(): mFounded(false){}
+
+    /*virtual*/ bool operator()(LLInventoryCategory* cat, LLInventoryItem* item)
+    {
+        if (mFounded || !item || item->getType() != LLAssetType::AT_LANDMARK)
+            return false;
+
+        LLLandmark* landmark = gLandmarkList.getAsset(item->getAssetUUID());
+        if (!landmark) // the landmark not been loaded yet
+            return false;
+
+        LLVector3d landmark_global_pos;
+        if (!landmark->getGlobalPos(landmark_global_pos))
+            return false;
+        mFounded = LLViewerParcelMgr::getInstance()->inAgentParcel(landmark_global_pos);
+        return mFounded;
+    }
 };
 
 static void fetch_landmarks(LLInventoryModel::cat_array_t& cats,
-							LLInventoryModel::item_array_t& items,
-							LLInventoryCollectFunctor& add)
+                            LLInventoryModel::item_array_t& items,
+                            LLInventoryCollectFunctor& add)
 {
-	// Look in "My Favorites"
-	const LLUUID favorites_folder_id = gInventory.findCategoryUUIDForType(LLFolderType::FT_FAVORITE);
-	gInventory.collectDescendentsIf(favorites_folder_id,
-		cats,
-		items,
-		LLInventoryModel::EXCLUDE_TRASH,
-		add);
-
-	// Look in "Landmarks"
-	const LLUUID landmarks_folder_id = gInventory.findCategoryUUIDForType(LLFolderType::FT_LANDMARK);
-	gInventory.collectDescendentsIf(landmarks_folder_id,
-		cats,
-		items,
-		LLInventoryModel::EXCLUDE_TRASH,
-		add);
+    // Look in "My Favorites"
+    const LLUUID favorites_folder_id = gInventory.findCategoryUUIDForType(LLFolderType::FT_FAVORITE);
+    gInventory.collectDescendentsIf(favorites_folder_id,
+        cats,
+        items,
+        LLInventoryModel::EXCLUDE_TRASH,
+        add);
+
+    // Look in "Landmarks"
+    const LLUUID landmarks_folder_id = gInventory.findCategoryUUIDForType(LLFolderType::FT_LANDMARK);
+    gInventory.collectDescendentsIf(landmarks_folder_id,
+        cats,
+        items,
+        LLInventoryModel::EXCLUDE_TRASH,
+        add);
 }
 
 LLInventoryModel::item_array_t LLLandmarkActions::fetchLandmarksByName(std::string& name, BOOL use_substring)
 {
-	LLInventoryModel::cat_array_t cats;
-	LLInventoryModel::item_array_t items;
-	LLFetchLandmarksByName by_name(name, use_substring);
-	fetch_landmarks(cats, items, by_name);
+    LLInventoryModel::cat_array_t cats;
+    LLInventoryModel::item_array_t items;
+    LLFetchLandmarksByName by_name(name, use_substring);
+    fetch_landmarks(cats, items, by_name);
 
-	return items;
+    return items;
 }
 
 bool LLLandmarkActions::landmarkAlreadyExists()
 {
-	// Determine whether there are landmarks pointing to the current global  agent position.
-	return findLandmarkForAgentPos() != NULL;
+    // Determine whether there are landmarks pointing to the current global  agent position.
+    return findLandmarkForAgentPos() != NULL;
 }
 
 //static
 bool LLLandmarkActions::hasParcelLandmark()
 {
-	LLFirstAgentParcelLandmark get_first_agent_landmark;
-	LLInventoryModel::cat_array_t cats;
-	LLInventoryModel::item_array_t items;
-	fetch_landmarks(cats, items, get_first_agent_landmark);
-	return !items.empty();
-	
+    LLFirstAgentParcelLandmark get_first_agent_landmark;
+    LLInventoryModel::cat_array_t cats;
+    LLInventoryModel::item_array_t items;
+    fetch_landmarks(cats, items, get_first_agent_landmark);
+    return !items.empty();
+
 }
 
 // *TODO: This could be made more efficient by only fetching the FIRST
 // landmark that meets the criteria
 LLViewerInventoryItem* LLLandmarkActions::findLandmarkForGlobalPos(const LLVector3d &pos)
 {
-	// Determine whether there are landmarks pointing to the current parcel.
-	LLInventoryModel::cat_array_t cats;
-	LLInventoryModel::item_array_t items;
-	LLFetchlLandmarkByPos is_current_pos_landmark(pos);
-	fetch_landmarks(cats, items, is_current_pos_landmark);
-
-	if(items.empty())
-	{
-		return NULL;
-	}
-
-	return items[0];
+    // Determine whether there are landmarks pointing to the current parcel.
+    LLInventoryModel::cat_array_t cats;
+    LLInventoryModel::item_array_t items;
+    LLFetchlLandmarkByPos is_current_pos_landmark(pos);
+    fetch_landmarks(cats, items, is_current_pos_landmark);
+
+    if(items.empty())
+    {
+        return NULL;
+    }
+
+    return items[0];
 }
 
 LLViewerInventoryItem* LLLandmarkActions::findLandmarkForAgentPos()
 {
-	return findLandmarkForGlobalPos(gAgent.getPositionGlobal());
+    return findLandmarkForGlobalPos(gAgent.getPositionGlobal());
 }
 
 void LLLandmarkActions::createLandmarkHere(
-	const std::string& name, 
-	const std::string& desc, 
-	const LLUUID& folder_id)
+    const std::string& name,
+    const std::string& desc,
+    const LLUUID& folder_id)
 {
-	if(!gAgent.getRegion())
-	{
-		LL_WARNS() << "No agent region" << LL_ENDL;
-		return;
-	}
-	LLParcel* agent_parcel = LLViewerParcelMgr::getInstance()->getAgentParcel();
-	if (!agent_parcel)
-	{
-		LL_WARNS() << "No agent parcel" << LL_ENDL;
-		return;
-	}
-
-	create_inventory_item(gAgent.getID(), gAgent.getSessionID(),
-		folder_id, LLTransactionID::tnull,
-		name, desc,
-		LLAssetType::AT_LANDMARK,
-		LLInventoryType::IT_LANDMARK,
+    if(!gAgent.getRegion())
+    {
+        LL_WARNS() << "No agent region" << LL_ENDL;
+        return;
+    }
+    LLParcel* agent_parcel = LLViewerParcelMgr::getInstance()->getAgentParcel();
+    if (!agent_parcel)
+    {
+        LL_WARNS() << "No agent parcel" << LL_ENDL;
+        return;
+    }
+
+    create_inventory_item(gAgent.getID(), gAgent.getSessionID(),
+        folder_id, LLTransactionID::tnull,
+        name, desc,
+        LLAssetType::AT_LANDMARK,
+        LLInventoryType::IT_LANDMARK,
         NO_INV_SUBTYPE, PERM_ALL,
-		NULL);
+        NULL);
 }
 
 void LLLandmarkActions::createLandmarkHere()
 {
-	std::string landmark_name, landmark_desc;
+    std::string landmark_name, landmark_desc;
 
-	LLAgentUI::buildLocationString(landmark_name, LLAgentUI::LOCATION_FORMAT_LANDMARK);
-	LLAgentUI::buildLocationString(landmark_desc, LLAgentUI::LOCATION_FORMAT_FULL);
-	const LLUUID folder_id = gInventory.findCategoryUUIDForType(LLFolderType::FT_LANDMARK);
+    LLAgentUI::buildLocationString(landmark_name, LLAgentUI::LOCATION_FORMAT_LANDMARK);
+    LLAgentUI::buildLocationString(landmark_desc, LLAgentUI::LOCATION_FORMAT_FULL);
+    const LLUUID folder_id = gInventory.findCategoryUUIDForType(LLFolderType::FT_LANDMARK);
 
-	createLandmarkHere(landmark_name, landmark_desc, folder_id);
+    createLandmarkHere(landmark_name, landmark_desc, folder_id);
 }
 
 void LLLandmarkActions::getSLURLfromPosGlobal(const LLVector3d& global_pos, slurl_callback_t cb, bool escaped /* = true */)
 {
-	std::string sim_name;
-	bool gotSimName = LLWorldMap::getInstance()->simNameFromPosGlobal(global_pos, sim_name);
-	if (gotSimName)
-	{
-	  std::string slurl = LLSLURL(sim_name, global_pos).getSLURLString();
-		cb(slurl);
-
-		return;
-	}
-	else
-	{
-		U64 new_region_handle = to_region_handle(global_pos);
-
-		LLWorldMapMessage::url_callback_t url_cb = boost::bind(&LLLandmarkActions::onRegionResponseSLURL,
-														cb,
-														global_pos,
-														escaped,
-														_2);
-
-		LLWorldMapMessage::getInstance()->sendHandleRegionRequest(new_region_handle, url_cb, std::string("unused"), false);
-	}
+    std::string sim_name;
+    bool gotSimName = LLWorldMap::getInstance()->simNameFromPosGlobal(global_pos, sim_name);
+    if (gotSimName)
+    {
+      std::string slurl = LLSLURL(sim_name, global_pos).getSLURLString();
+        cb(slurl);
+
+        return;
+    }
+    else
+    {
+        U64 new_region_handle = to_region_handle(global_pos);
+
+        LLWorldMapMessage::url_callback_t url_cb = boost::bind(&LLLandmarkActions::onRegionResponseSLURL,
+                                                        cb,
+                                                        global_pos,
+                                                        escaped,
+                                                        _2);
+
+        LLWorldMapMessage::getInstance()->sendHandleRegionRequest(new_region_handle, url_cb, std::string("unused"), false);
+    }
 }
 
 void LLLandmarkActions::getRegionNameAndCoordsFromPosGlobal(const LLVector3d& global_pos, region_name_and_coords_callback_t cb)
 {
-	std::string sim_name;
-	LLSimInfo* sim_infop = LLWorldMap::getInstance()->simInfoFromPosGlobal(global_pos);
-	if (sim_infop)
-	{
-		LLVector3 pos = sim_infop->getLocalPos(global_pos);
-		std::string name = sim_infop->getName() ;
-		cb(name, ll_round(pos.mV[VX]), ll_round(pos.mV[VY]),ll_round(pos.mV[VZ]));
-	}
-	else
-	{
-		U64 new_region_handle = to_region_handle(global_pos);
-
-		LLWorldMapMessage::url_callback_t url_cb = boost::bind(&LLLandmarkActions::onRegionResponseNameAndCoords,
-														cb,
-														global_pos,
-														_1);
-
-		LLWorldMapMessage::getInstance()->sendHandleRegionRequest(new_region_handle, url_cb, std::string("unused"), false);
-	}
+    std::string sim_name;
+    LLSimInfo* sim_infop = LLWorldMap::getInstance()->simInfoFromPosGlobal(global_pos);
+    if (sim_infop)
+    {
+        LLVector3 pos = sim_infop->getLocalPos(global_pos);
+        std::string name = sim_infop->getName() ;
+        cb(name, ll_round(pos.mV[VX]), ll_round(pos.mV[VY]),ll_round(pos.mV[VZ]));
+    }
+    else
+    {
+        U64 new_region_handle = to_region_handle(global_pos);
+
+        LLWorldMapMessage::url_callback_t url_cb = boost::bind(&LLLandmarkActions::onRegionResponseNameAndCoords,
+                                                        cb,
+                                                        global_pos,
+                                                        _1);
+
+        LLWorldMapMessage::getInstance()->sendHandleRegionRequest(new_region_handle, url_cb, std::string("unused"), false);
+    }
 }
 
 void LLLandmarkActions::onRegionResponseSLURL(slurl_callback_t cb,
-										 const LLVector3d& global_pos,
-										 bool escaped,
-										 const std::string& url)
+                                         const LLVector3d& global_pos,
+                                         bool escaped,
+                                         const std::string& url)
 {
-	std::string sim_name;
-	std::string slurl;
-	bool gotSimName = LLWorldMap::getInstance()->simNameFromPosGlobal(global_pos, sim_name);
-	if (gotSimName)
-	{
-	  slurl = LLSLURL(sim_name, global_pos).getSLURLString();
-	}
-	else
-	{
-		slurl = "";
-	}
-
-	cb(slurl);
+    std::string sim_name;
+    std::string slurl;
+    bool gotSimName = LLWorldMap::getInstance()->simNameFromPosGlobal(global_pos, sim_name);
+    if (gotSimName)
+    {
+      slurl = LLSLURL(sim_name, global_pos).getSLURLString();
+    }
+    else
+    {
+        slurl = "";
+    }
+
+    cb(slurl);
 }
 
 void LLLandmarkActions::onRegionResponseNameAndCoords(region_name_and_coords_callback_t cb,
-										 const LLVector3d& global_pos,
-										 U64 region_handle)
+                                         const LLVector3d& global_pos,
+                                         U64 region_handle)
 {
-	LLSimInfo* sim_infop = LLWorldMap::getInstance()->simInfoFromHandle(region_handle);
-	if (sim_infop)
-	{
-		LLVector3 local_pos = sim_infop->getLocalPos(global_pos);
-		std::string name = sim_infop->getName() ;
-		cb(name, ll_round(local_pos.mV[VX]), ll_round(local_pos.mV[VY]), ll_round(local_pos.mV[VZ]));
-	}
+    LLSimInfo* sim_infop = LLWorldMap::getInstance()->simInfoFromHandle(region_handle);
+    if (sim_infop)
+    {
+        LLVector3 local_pos = sim_infop->getLocalPos(global_pos);
+        std::string name = sim_infop->getName() ;
+        cb(name, ll_round(local_pos.mV[VX]), ll_round(local_pos.mV[VY]), ll_round(local_pos.mV[VZ]));
+    }
 }
 
 bool LLLandmarkActions::getLandmarkGlobalPos(const LLUUID& landmarkInventoryItemID, LLVector3d& posGlobal)
 {
-	LLViewerInventoryItem* item = gInventory.getItem(landmarkInventoryItemID);
-	if (NULL == item)
-		return false;
+    LLViewerInventoryItem* item = gInventory.getItem(landmarkInventoryItemID);
+    if (NULL == item)
+        return false;
 
-	const LLUUID& asset_id = item->getAssetUUID();
+    const LLUUID& asset_id = item->getAssetUUID();
 
-	LLLandmark* landmark = gLandmarkList.getAsset(asset_id, NULL);
-	if (NULL == landmark)
-		return false;
+    LLLandmark* landmark = gLandmarkList.getAsset(asset_id, NULL);
+    if (NULL == landmark)
+        return false;
 
-	return landmark->getGlobalPos(posGlobal);
+    return landmark->getGlobalPos(posGlobal);
 }
 
 LLLandmark* LLLandmarkActions::getLandmark(const LLUUID& landmarkInventoryItemID, LLLandmarkList::loaded_callback_t cb)
 {
-	LLViewerInventoryItem* item = gInventory.getItem(landmarkInventoryItemID);
-	if (NULL == item)
-		return NULL;
+    LLViewerInventoryItem* item = gInventory.getItem(landmarkInventoryItemID);
+    if (NULL == item)
+        return NULL;
 
-	const LLUUID& asset_id = item->getAssetUUID();
+    const LLUUID& asset_id = item->getAssetUUID();
 
-	LLLandmark* landmark = gLandmarkList.getAsset(asset_id, cb);
-	if (landmark)
-	{
-		return landmark;
-	}
+    LLLandmark* landmark = gLandmarkList.getAsset(asset_id, cb);
+    if (landmark)
+    {
+        return landmark;
+    }
 
-	return NULL;
+    return NULL;
 }
 
 void LLLandmarkActions::copySLURLtoClipboard(const LLUUID& landmarkInventoryItemID)
 {
-	LLLandmark* landmark = LLLandmarkActions::getLandmark(landmarkInventoryItemID);
-	if(landmark)
-	{
-		LLVector3d global_pos;
-		landmark->getGlobalPos(global_pos);
-		LLLandmarkActions::getSLURLfromPosGlobal(global_pos,&copy_slurl_to_clipboard_callback,true);
-	}
+    LLLandmark* landmark = LLLandmarkActions::getLandmark(landmarkInventoryItemID);
+    if(landmark)
+    {
+        LLVector3d global_pos;
+        landmark->getGlobalPos(global_pos);
+        LLLandmarkActions::getSLURLfromPosGlobal(global_pos,&copy_slurl_to_clipboard_callback,true);
+    }
 }
 
 void copy_slurl_to_clipboard_callback(const std::string& slurl)
 {
-	gViewerWindow->getWindow()->copyTextToClipboard(utf8str_to_wstring(slurl));
-	LLSD args;
-	args["SLURL"] = slurl;
-	LLNotificationsUtil::add("CopySLURL", args);
+    gViewerWindow->getWindow()->copyTextToClipboard(utf8str_to_wstring(slurl));
+    LLSD args;
+    args["SLURL"] = slurl;
+    LLNotificationsUtil::add("CopySLURL", args);
 }