Merge branch 'main' into marchcat/x-b-merge

# Conflicts:
#	autobuild.xml
#	indra/cmake/ConfigurePkgConfig.cmake
#	indra/cmake/ICU4C.cmake
#	indra/media_plugins/gstreamer010/llmediaimplgstreamer_syms.cpp
#	indra/media_plugins/gstreamer010/llmediaimplgstreamer_syms.h
#	indra/media_plugins/gstreamer010/llmediaimplgstreamertriviallogging.h
#	indra/media_plugins/gstreamer010/llmediaimplgstreamervidplug.cpp
#	indra/media_plugins/gstreamer010/llmediaimplgstreamervidplug.h
#	indra/media_plugins/gstreamer010/media_plugin_gstreamer010.cpp
#	indra/newview/llappviewerlinux_api.h
#	indra/newview/llappviewerlinux_api_dbus.cpp
#	indra/newview/llappviewerlinux_api_dbus.h
#	indra/newview/llfloateremojipicker.cpp
#	indra/newview/lloutfitslist.cpp

1 files changed, 1011 insertions, 1011 deletions

diff --git a/indra/newview/llfloatersnapshot.cpp b/indra/newview/llfloatersnapshot.cpp
index ca2069cbfc..68ed0f5873 100644
--- a/indra/newview/llfloatersnapshot.cpp
+++ b/indra/newview/llfloatersnapshot.cpp
@@ -1,25 +1,25 @@
-/** 
+/**
  * @file llfloatersnapshot.cpp
  * @brief Snapshot preview window, allowing saving, e-mailing, etc.
  *
  * $LicenseInfo:firstyear=2004&license=viewerlgpl$
  * Second Life Viewer Source Code
  * Copyright (C) 2016, 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$
  */
@@ -33,7 +33,7 @@
 #include "llcheckboxctrl.h"
 #include "llcombobox.h"
 #include "llpostcard.h"
-#include "llresmgr.h"		// LLLocale
+#include "llresmgr.h"       // LLLocale
 #include "llsdserialize.h"
 #include "llsidetraypanelcontainer.h"
 #include "llsnapshotlivepreview.h"
@@ -58,199 +58,199 @@ static LLDefaultChildRegistry::Register<LLSnapshotFloaterView> r("snapshot_float
 // virtual
 LLPanelSnapshot* LLFloaterSnapshot::Impl::getActivePanel(LLFloaterSnapshotBase* floater, bool ok_if_not_found)
 {
-	LLSideTrayPanelContainer* panel_container = floater->getChild<LLSideTrayPanelContainer>("panel_container");
-	LLPanelSnapshot* active_panel = dynamic_cast<LLPanelSnapshot*>(panel_container->getCurrentPanel());
-	if (!ok_if_not_found)
-	{
-		llassert_always(active_panel != NULL);
-	}
-	return active_panel;
+    LLSideTrayPanelContainer* panel_container = floater->getChild<LLSideTrayPanelContainer>("panel_container");
+    LLPanelSnapshot* active_panel = dynamic_cast<LLPanelSnapshot*>(panel_container->getCurrentPanel());
+    if (!ok_if_not_found)
+    {
+        llassert_always(active_panel != NULL);
+    }
+    return active_panel;
 }
 
 // virtual
 LLSnapshotModel::ESnapshotType LLFloaterSnapshotBase::ImplBase::getActiveSnapshotType(LLFloaterSnapshotBase* floater)
 {
-	LLPanelSnapshot* spanel = getActivePanel(floater);
+    LLPanelSnapshot* spanel = getActivePanel(floater);
 
-	//return type;
+    //return type;
     if (spanel)
     {
         return spanel->getSnapshotType();
     }
-	return LLSnapshotModel::SNAPSHOT_WEB;
+    return LLSnapshotModel::SNAPSHOT_WEB;
 }
 
 // virtual
 LLSnapshotModel::ESnapshotFormat LLFloaterSnapshot::Impl::getImageFormat(LLFloaterSnapshotBase* floater)
 {
-	LLPanelSnapshot* active_panel = getActivePanel(floater);
-	// FIXME: if the default is not PNG, profile uploads may fail.
-	return active_panel ? active_panel->getImageFormat() : LLSnapshotModel::SNAPSHOT_FORMAT_PNG;
+    LLPanelSnapshot* active_panel = getActivePanel(floater);
+    // FIXME: if the default is not PNG, profile uploads may fail.
+    return active_panel ? active_panel->getImageFormat() : LLSnapshotModel::SNAPSHOT_FORMAT_PNG;
 }
 
 LLSpinCtrl* LLFloaterSnapshot::Impl::getWidthSpinner(LLFloaterSnapshotBase* floater)
 {
-	LLPanelSnapshot* active_panel = getActivePanel(floater);
-	return active_panel ? active_panel->getWidthSpinner() : floater->getChild<LLSpinCtrl>("snapshot_width");
+    LLPanelSnapshot* active_panel = getActivePanel(floater);
+    return active_panel ? active_panel->getWidthSpinner() : floater->getChild<LLSpinCtrl>("snapshot_width");
 }
 
 LLSpinCtrl* LLFloaterSnapshot::Impl::getHeightSpinner(LLFloaterSnapshotBase* floater)
 {
-	LLPanelSnapshot* active_panel = getActivePanel(floater);
-	return active_panel ? active_panel->getHeightSpinner() : floater->getChild<LLSpinCtrl>("snapshot_height");
+    LLPanelSnapshot* active_panel = getActivePanel(floater);
+    return active_panel ? active_panel->getHeightSpinner() : floater->getChild<LLSpinCtrl>("snapshot_height");
 }
 
 void LLFloaterSnapshot::Impl::enableAspectRatioCheckbox(LLFloaterSnapshotBase* floater, BOOL enable)
 {
-	LLPanelSnapshot* active_panel = getActivePanel(floater);
-	if (active_panel)
-	{
-		active_panel->enableAspectRatioCheckbox(enable);
-	}
+    LLPanelSnapshot* active_panel = getActivePanel(floater);
+    if (active_panel)
+    {
+        active_panel->enableAspectRatioCheckbox(enable);
+    }
 }
 
 void LLFloaterSnapshot::Impl::setAspectRatioCheckboxValue(LLFloaterSnapshotBase* floater, BOOL checked)
 {
-	LLPanelSnapshot* active_panel = getActivePanel(floater);
-	if (active_panel)
-	{
-		active_panel->getChild<LLUICtrl>(active_panel->getAspectRatioCBName())->setValue(checked);
-	}
+    LLPanelSnapshot* active_panel = getActivePanel(floater);
+    if (active_panel)
+    {
+        active_panel->getChild<LLUICtrl>(active_panel->getAspectRatioCBName())->setValue(checked);
+    }
 }
 
 LLSnapshotLivePreview* LLFloaterSnapshotBase::getPreviewView()
 {
-	return impl->getPreviewView();
+    return impl->getPreviewView();
 }
 
 LLSnapshotLivePreview* LLFloaterSnapshotBase::ImplBase::getPreviewView()
 {
-	LLSnapshotLivePreview* previewp = (LLSnapshotLivePreview*)mPreviewHandle.get();
-	return previewp;
+    LLSnapshotLivePreview* previewp = (LLSnapshotLivePreview*)mPreviewHandle.get();
+    return previewp;
 }
 
 // virtual
 LLSnapshotModel::ESnapshotLayerType LLFloaterSnapshot::Impl::getLayerType(LLFloaterSnapshotBase* floater)
 {
-	LLSnapshotModel::ESnapshotLayerType type = LLSnapshotModel::SNAPSHOT_TYPE_COLOR;
-	LLSD value = floater->getChild<LLUICtrl>("layer_types")->getValue();
-	const std::string id = value.asString();
-	if (id == "colors")
-		type = LLSnapshotModel::SNAPSHOT_TYPE_COLOR;
-	else if (id == "depth")
-		type = LLSnapshotModel::SNAPSHOT_TYPE_DEPTH;
-	return type;
+    LLSnapshotModel::ESnapshotLayerType type = LLSnapshotModel::SNAPSHOT_TYPE_COLOR;
+    LLSD value = floater->getChild<LLUICtrl>("layer_types")->getValue();
+    const std::string id = value.asString();
+    if (id == "colors")
+        type = LLSnapshotModel::SNAPSHOT_TYPE_COLOR;
+    else if (id == "depth")
+        type = LLSnapshotModel::SNAPSHOT_TYPE_DEPTH;
+    return type;
 }
 
 void LLFloaterSnapshot::Impl::setResolution(LLFloaterSnapshotBase* floater, const std::string& comboname)
 {
-	LLComboBox* combo = floater->getChild<LLComboBox>(comboname);
-		combo->setVisible(TRUE);
-	updateResolution(combo, floater, FALSE); // to sync spinners with combo
+    LLComboBox* combo = floater->getChild<LLComboBox>(comboname);
+        combo->setVisible(TRUE);
+    updateResolution(combo, floater, FALSE); // to sync spinners with combo
 }
 
-//virtual 
+//virtual
 void LLFloaterSnapshotBase::ImplBase::updateLayout(LLFloaterSnapshotBase* floaterp)
 {
-	LLSnapshotLivePreview* previewp = getPreviewView();
-
-	//BD - Automatically calculate the size of our snapshot window to enlarge
-	//     the snapshot preview to its maximum size, this is especially helpfull
-	//     for pretty much every aspect ratio other than 1:1.
-	F32 panel_width = 400.f * gViewerWindow->getWorldViewAspectRatio();
-
-	//BD - Make sure we clamp at 700 here because 700 would be for 16:9 which we
-	//     consider the maximum. Everything bigger will be clamped and will have
-	//     a slightly smaller preview window which most likely won't fill up the
-	//     whole snapshot floater as it should.
-	if(panel_width > 700.f)
-	{
-		panel_width = 700.f;
-	}
-
-	S32 floater_width = 224.f;
-	if(mAdvanced)
-	{
-		floater_width = floater_width + panel_width;
-	}
-
-	LLUICtrl* thumbnail_placeholder = floaterp->getChild<LLUICtrl>("thumbnail_placeholder");
-	thumbnail_placeholder->setVisible(mAdvanced);
-
-	floaterp->getChild<LLUICtrl>("image_res_text")->setVisible(mAdvanced);
-	floaterp->getChild<LLUICtrl>("file_size_label")->setVisible(mAdvanced);
+    LLSnapshotLivePreview* previewp = getPreviewView();
+
+    //BD - Automatically calculate the size of our snapshot window to enlarge
+    //     the snapshot preview to its maximum size, this is especially helpfull
+    //     for pretty much every aspect ratio other than 1:1.
+    F32 panel_width = 400.f * gViewerWindow->getWorldViewAspectRatio();
+
+    //BD - Make sure we clamp at 700 here because 700 would be for 16:9 which we
+    //     consider the maximum. Everything bigger will be clamped and will have
+    //     a slightly smaller preview window which most likely won't fill up the
+    //     whole snapshot floater as it should.
+    if(panel_width > 700.f)
+    {
+        panel_width = 700.f;
+    }
+
+    S32 floater_width = 224.f;
+    if(mAdvanced)
+    {
+        floater_width = floater_width + panel_width;
+    }
+
+    LLUICtrl* thumbnail_placeholder = floaterp->getChild<LLUICtrl>("thumbnail_placeholder");
+    thumbnail_placeholder->setVisible(mAdvanced);
+
+    floaterp->getChild<LLUICtrl>("image_res_text")->setVisible(mAdvanced);
+    floaterp->getChild<LLUICtrl>("file_size_label")->setVisible(mAdvanced);
     if (floaterp->hasChild("360_label", TRUE))
-    { 
+    {
         floaterp->getChild<LLUICtrl>("360_label")->setVisible(mAdvanced);
     }
-	if (!mSkipReshaping)
-	{
+    if (!mSkipReshaping)
+    {
         thumbnail_placeholder->reshape(panel_width, thumbnail_placeholder->getRect().getHeight());
         if (!floaterp->isMinimized())
         {
             floaterp->reshape(floater_width, floaterp->getRect().getHeight());
         }
-	}
-
-	bool use_freeze_frame = floaterp->getChild<LLUICtrl>("freeze_frame_check")->getValue().asBoolean();
-
-	if (use_freeze_frame)
-	{
-		// stop all mouse events at fullscreen preview layer
-		floaterp->getParent()->setMouseOpaque(TRUE);
-		
-		// shrink to smaller layout
-		// *TODO: unneeded?
-		floaterp->reshape(floaterp->getRect().getWidth(), floaterp->getRect().getHeight());
-
-		// can see and interact with fullscreen preview now
-		if (previewp)
-		{
-			previewp->setVisible(TRUE);
-			previewp->setEnabled(TRUE);
-		}
-
-		//RN: freeze all avatars
-		LLCharacter* avatarp;
-		for (std::vector<LLCharacter*>::iterator iter = LLCharacter::sInstances.begin();
-			iter != LLCharacter::sInstances.end(); ++iter)
-		{
-			avatarp = *iter;
-			floaterp->impl->mAvatarPauseHandles.push_back(avatarp->requestPause());
-		}
-
-		// freeze everything else
-		gSavedSettings.setBOOL("FreezeTime", TRUE);
-
-		if (LLToolMgr::getInstance()->getCurrentToolset() != gCameraToolset)
-		{
-			floaterp->impl->mLastToolset = LLToolMgr::getInstance()->getCurrentToolset();
-			LLToolMgr::getInstance()->setCurrentToolset(gCameraToolset);
-		}
-	}
-	else // turning off freeze frame mode
-	{
-		floaterp->getParent()->setMouseOpaque(FALSE);
-		// *TODO: unneeded?
-		floaterp->reshape(floaterp->getRect().getWidth(), floaterp->getRect().getHeight());
-		if (previewp)
-		{
-			previewp->setVisible(FALSE);
-			previewp->setEnabled(FALSE);
-		}
-
-		//RN: thaw all avatars
-		floaterp->impl->mAvatarPauseHandles.clear();
-
-		// thaw everything else
-		gSavedSettings.setBOOL("FreezeTime", FALSE);
-
-		// restore last tool (e.g. pie menu, etc)
-		if (floaterp->impl->mLastToolset)
-		{
-			LLToolMgr::getInstance()->setCurrentToolset(floaterp->impl->mLastToolset);
-		}
-	}
+    }
+
+    bool use_freeze_frame = floaterp->getChild<LLUICtrl>("freeze_frame_check")->getValue().asBoolean();
+
+    if (use_freeze_frame)
+    {
+        // stop all mouse events at fullscreen preview layer
+        floaterp->getParent()->setMouseOpaque(TRUE);
+
+        // shrink to smaller layout
+        // *TODO: unneeded?
+        floaterp->reshape(floaterp->getRect().getWidth(), floaterp->getRect().getHeight());
+
+        // can see and interact with fullscreen preview now
+        if (previewp)
+        {
+            previewp->setVisible(TRUE);
+            previewp->setEnabled(TRUE);
+        }
+
+        //RN: freeze all avatars
+        LLCharacter* avatarp;
+        for (std::vector<LLCharacter*>::iterator iter = LLCharacter::sInstances.begin();
+            iter != LLCharacter::sInstances.end(); ++iter)
+        {
+            avatarp = *iter;
+            floaterp->impl->mAvatarPauseHandles.push_back(avatarp->requestPause());
+        }
+
+        // freeze everything else
+        gSavedSettings.setBOOL("FreezeTime", TRUE);
+
+        if (LLToolMgr::getInstance()->getCurrentToolset() != gCameraToolset)
+        {
+            floaterp->impl->mLastToolset = LLToolMgr::getInstance()->getCurrentToolset();
+            LLToolMgr::getInstance()->setCurrentToolset(gCameraToolset);
+        }
+    }
+    else // turning off freeze frame mode
+    {
+        floaterp->getParent()->setMouseOpaque(FALSE);
+        // *TODO: unneeded?
+        floaterp->reshape(floaterp->getRect().getWidth(), floaterp->getRect().getHeight());
+        if (previewp)
+        {
+            previewp->setVisible(FALSE);
+            previewp->setEnabled(FALSE);
+        }
+
+        //RN: thaw all avatars
+        floaterp->impl->mAvatarPauseHandles.clear();
+
+        // thaw everything else
+        gSavedSettings.setBOOL("FreezeTime", FALSE);
+
+        // restore last tool (e.g. pie menu, etc)
+        if (floaterp->impl->mLastToolset)
+        {
+            LLToolMgr::getInstance()->setCurrentToolset(floaterp->impl->mLastToolset);
+        }
+    }
 }
 
 // This is the main function that keeps all the GUI controls in sync with the saved settings.
@@ -262,212 +262,212 @@ void LLFloaterSnapshotBase::ImplBase::updateLayout(LLFloaterSnapshotBase* floate
 // virtual
 void LLFloaterSnapshot::Impl::updateControls(LLFloaterSnapshotBase* floater)
 {
-	LLSnapshotModel::ESnapshotType shot_type = getActiveSnapshotType(floater);
-	LLSnapshotModel::ESnapshotFormat shot_format = (LLSnapshotModel::ESnapshotFormat)gSavedSettings.getS32("SnapshotFormat");
-	LLSnapshotModel::ESnapshotLayerType layer_type = getLayerType(floater);
-
-	floater->getChild<LLComboBox>("local_format_combo")->selectNthItem(gSavedSettings.getS32("SnapshotFormat"));
-	floater->getChildView("layer_types")->setEnabled(shot_type == LLSnapshotModel::SNAPSHOT_LOCAL);
-
-	LLPanelSnapshot* active_panel = getActivePanel(floater);
-	if (active_panel)
-	{
-		LLSpinCtrl* width_ctrl = getWidthSpinner(floater);
-		LLSpinCtrl* height_ctrl = getHeightSpinner(floater);
-
-		// Initialize spinners.
-		if (width_ctrl->getValue().asInteger() == 0)
-		{
-			S32 w = gViewerWindow->getWindowWidthRaw();
-			LL_DEBUGS() << "Initializing width spinner (" << width_ctrl->getName() << "): " << w << LL_ENDL;
-			width_ctrl->setValue(w);
-			if (getActiveSnapshotType(floater) == LLSnapshotModel::SNAPSHOT_TEXTURE)
-			{
-				width_ctrl->setIncrement(w >> 1);
-			}
-		}
-		if (height_ctrl->getValue().asInteger() == 0)
-		{
-			S32 h = gViewerWindow->getWindowHeightRaw();
-			LL_DEBUGS() << "Initializing height spinner (" << height_ctrl->getName() << "): " << h << LL_ENDL;
-			height_ctrl->setValue(h);
-			if (getActiveSnapshotType(floater) == LLSnapshotModel::SNAPSHOT_TEXTURE)
-			{
-				height_ctrl->setIncrement(h >> 1);
-			}
-		}
-
-		// Clamp snapshot resolution to window size when showing UI or HUD in snapshot.
-		if (gSavedSettings.getBOOL("RenderUIInSnapshot") || gSavedSettings.getBOOL("RenderHUDInSnapshot"))
-		{
-			S32 width = gViewerWindow->getWindowWidthRaw();
-			S32 height = gViewerWindow->getWindowHeightRaw();
-
-			width_ctrl->setMaxValue(width);
-
-			height_ctrl->setMaxValue(height);
-
-			if (width_ctrl->getValue().asInteger() > width)
-			{
-				width_ctrl->forceSetValue(width);
-			}
-			if (height_ctrl->getValue().asInteger() > height)
-			{
-				height_ctrl->forceSetValue(height);
-			}
-		}
-		else
-		{
-			width_ctrl->setMaxValue(MAX_SNAPSHOT_IMAGE_SIZE);
-			height_ctrl->setMaxValue(MAX_SNAPSHOT_IMAGE_SIZE);
-		}
-	}
-		
-	LLSnapshotLivePreview* previewp = getPreviewView();
-	BOOL got_bytes = previewp && previewp->getDataSize() > 0;
-	BOOL got_snap = previewp && previewp->getSnapshotUpToDate();
-
-	// *TODO: Separate maximum size for Web images from postcards
-	LL_DEBUGS() << "Is snapshot up-to-date? " << got_snap << LL_ENDL;
-
-	LLLocale locale(LLLocale::USER_LOCALE);
-	std::string bytes_string;
-	if (got_snap)
-	{
-		LLResMgr::getInstance()->getIntegerString(bytes_string, (previewp->getDataSize()) >> 10 );
-	}
-
-	// Update displayed image resolution.
-	LLTextBox* image_res_tb = floater->getChild<LLTextBox>("image_res_text");
-	image_res_tb->setVisible(got_snap);
-	if (got_snap)
-	{
-		image_res_tb->setTextArg("[WIDTH]", llformat("%d", previewp->getEncodedImageWidth()));
-		image_res_tb->setTextArg("[HEIGHT]", llformat("%d", previewp->getEncodedImageHeight()));
-	}
-
-	floater->getChild<LLUICtrl>("file_size_label")->setTextArg("[SIZE]", got_snap ? bytes_string : floater->getString("unknown"));
-	floater->getChild<LLUICtrl>("file_size_label")->setColor(
-			shot_type == LLSnapshotModel::SNAPSHOT_POSTCARD
-			&& got_bytes
-			&& previewp->getDataSize() > MAX_POSTCARD_DATASIZE ? LLUIColor(LLColor4::red) : LLUIColorTable::instance().getColor( "LabelTextColor" ));
-
-	// Update the width and height spinners based on the corresponding resolution combos. (?)
-	switch(shot_type)
-	{
-	  case LLSnapshotModel::SNAPSHOT_WEB:
-		layer_type = LLSnapshotModel::SNAPSHOT_TYPE_COLOR;
-		floater->getChild<LLUICtrl>("layer_types")->setValue("colors");
-		setResolution(floater, "profile_size_combo");
-		break;
-	  case LLSnapshotModel::SNAPSHOT_POSTCARD:
-		layer_type = LLSnapshotModel::SNAPSHOT_TYPE_COLOR;
-		floater->getChild<LLUICtrl>("layer_types")->setValue("colors");
-		setResolution(floater, "postcard_size_combo");
-		break;
-	  case LLSnapshotModel::SNAPSHOT_TEXTURE:
-		layer_type = LLSnapshotModel::SNAPSHOT_TYPE_COLOR;
-		floater->getChild<LLUICtrl>("layer_types")->setValue("colors");
-		setResolution(floater, "texture_size_combo");
-		break;
-	  case  LLSnapshotModel::SNAPSHOT_LOCAL:
-		setResolution(floater, "local_size_combo");
-		break;
-	  default:
-		break;
-	}
-	setAspectRatioCheckboxValue(floater, !floater->impl->mAspectRatioCheckOff && gSavedSettings.getBOOL("KeepAspectForSnapshot"));
-
-	if (previewp)
-	{
-		previewp->setSnapshotType(shot_type);
-		previewp->setSnapshotFormat(shot_format);
-		previewp->setSnapshotBufferType(layer_type);
-	}
-
-	LLPanelSnapshot* current_panel = Impl::getActivePanel(floater);
-	if (current_panel)
-	{
-		LLSD info;
-		info["have-snapshot"] = got_snap;
-		current_panel->updateControls(info);
-	}
-	LL_DEBUGS() << "finished updating controls" << LL_ENDL;
+    LLSnapshotModel::ESnapshotType shot_type = getActiveSnapshotType(floater);
+    LLSnapshotModel::ESnapshotFormat shot_format = (LLSnapshotModel::ESnapshotFormat)gSavedSettings.getS32("SnapshotFormat");
+    LLSnapshotModel::ESnapshotLayerType layer_type = getLayerType(floater);
+
+    floater->getChild<LLComboBox>("local_format_combo")->selectNthItem(gSavedSettings.getS32("SnapshotFormat"));
+    floater->getChildView("layer_types")->setEnabled(shot_type == LLSnapshotModel::SNAPSHOT_LOCAL);
+
+    LLPanelSnapshot* active_panel = getActivePanel(floater);
+    if (active_panel)
+    {
+        LLSpinCtrl* width_ctrl = getWidthSpinner(floater);
+        LLSpinCtrl* height_ctrl = getHeightSpinner(floater);
+
+        // Initialize spinners.
+        if (width_ctrl->getValue().asInteger() == 0)
+        {
+            S32 w = gViewerWindow->getWindowWidthRaw();
+            LL_DEBUGS() << "Initializing width spinner (" << width_ctrl->getName() << "): " << w << LL_ENDL;
+            width_ctrl->setValue(w);
+            if (getActiveSnapshotType(floater) == LLSnapshotModel::SNAPSHOT_TEXTURE)
+            {
+                width_ctrl->setIncrement(w >> 1);
+            }
+        }
+        if (height_ctrl->getValue().asInteger() == 0)
+        {
+            S32 h = gViewerWindow->getWindowHeightRaw();
+            LL_DEBUGS() << "Initializing height spinner (" << height_ctrl->getName() << "): " << h << LL_ENDL;
+            height_ctrl->setValue(h);
+            if (getActiveSnapshotType(floater) == LLSnapshotModel::SNAPSHOT_TEXTURE)
+            {
+                height_ctrl->setIncrement(h >> 1);
+            }
+        }
+
+        // Clamp snapshot resolution to window size when showing UI or HUD in snapshot.
+        if (gSavedSettings.getBOOL("RenderUIInSnapshot") || gSavedSettings.getBOOL("RenderHUDInSnapshot"))
+        {
+            S32 width = gViewerWindow->getWindowWidthRaw();
+            S32 height = gViewerWindow->getWindowHeightRaw();
+
+            width_ctrl->setMaxValue(width);
+
+            height_ctrl->setMaxValue(height);
+
+            if (width_ctrl->getValue().asInteger() > width)
+            {
+                width_ctrl->forceSetValue(width);
+            }
+            if (height_ctrl->getValue().asInteger() > height)
+            {
+                height_ctrl->forceSetValue(height);
+            }
+        }
+        else
+        {
+            width_ctrl->setMaxValue(MAX_SNAPSHOT_IMAGE_SIZE);
+            height_ctrl->setMaxValue(MAX_SNAPSHOT_IMAGE_SIZE);
+        }
+    }
+
+    LLSnapshotLivePreview* previewp = getPreviewView();
+    BOOL got_bytes = previewp && previewp->getDataSize() > 0;
+    BOOL got_snap = previewp && previewp->getSnapshotUpToDate();
+
+    // *TODO: Separate maximum size for Web images from postcards
+    LL_DEBUGS() << "Is snapshot up-to-date? " << got_snap << LL_ENDL;
+
+    LLLocale locale(LLLocale::USER_LOCALE);
+    std::string bytes_string;
+    if (got_snap)
+    {
+        LLResMgr::getInstance()->getIntegerString(bytes_string, (previewp->getDataSize()) >> 10 );
+    }
+
+    // Update displayed image resolution.
+    LLTextBox* image_res_tb = floater->getChild<LLTextBox>("image_res_text");
+    image_res_tb->setVisible(got_snap);
+    if (got_snap)
+    {
+        image_res_tb->setTextArg("[WIDTH]", llformat("%d", previewp->getEncodedImageWidth()));
+        image_res_tb->setTextArg("[HEIGHT]", llformat("%d", previewp->getEncodedImageHeight()));
+    }
+
+    floater->getChild<LLUICtrl>("file_size_label")->setTextArg("[SIZE]", got_snap ? bytes_string : floater->getString("unknown"));
+    floater->getChild<LLUICtrl>("file_size_label")->setColor(
+            shot_type == LLSnapshotModel::SNAPSHOT_POSTCARD
+            && got_bytes
+            && previewp->getDataSize() > MAX_POSTCARD_DATASIZE ? LLUIColor(LLColor4::red) : LLUIColorTable::instance().getColor( "LabelTextColor" ));
+
+    // Update the width and height spinners based on the corresponding resolution combos. (?)
+    switch(shot_type)
+    {
+      case LLSnapshotModel::SNAPSHOT_WEB:
+        layer_type = LLSnapshotModel::SNAPSHOT_TYPE_COLOR;
+        floater->getChild<LLUICtrl>("layer_types")->setValue("colors");
+        setResolution(floater, "profile_size_combo");
+        break;
+      case LLSnapshotModel::SNAPSHOT_POSTCARD:
+        layer_type = LLSnapshotModel::SNAPSHOT_TYPE_COLOR;
+        floater->getChild<LLUICtrl>("layer_types")->setValue("colors");
+        setResolution(floater, "postcard_size_combo");
+        break;
+      case LLSnapshotModel::SNAPSHOT_TEXTURE:
+        layer_type = LLSnapshotModel::SNAPSHOT_TYPE_COLOR;
+        floater->getChild<LLUICtrl>("layer_types")->setValue("colors");
+        setResolution(floater, "texture_size_combo");
+        break;
+      case  LLSnapshotModel::SNAPSHOT_LOCAL:
+        setResolution(floater, "local_size_combo");
+        break;
+      default:
+        break;
+    }
+    setAspectRatioCheckboxValue(floater, !floater->impl->mAspectRatioCheckOff && gSavedSettings.getBOOL("KeepAspectForSnapshot"));
+
+    if (previewp)
+    {
+        previewp->setSnapshotType(shot_type);
+        previewp->setSnapshotFormat(shot_format);
+        previewp->setSnapshotBufferType(layer_type);
+    }
+
+    LLPanelSnapshot* current_panel = Impl::getActivePanel(floater);
+    if (current_panel)
+    {
+        LLSD info;
+        info["have-snapshot"] = got_snap;
+        current_panel->updateControls(info);
+    }
+    LL_DEBUGS() << "finished updating controls" << LL_ENDL;
 }
 
 //virtual
 void LLFloaterSnapshotBase::ImplBase::setStatus(EStatus status, bool ok, const std::string& msg)
 {
-	switch (status)
-	{
-	case STATUS_READY:
-		setWorking(false);
-		setFinished(false);
-		break;
-	case STATUS_WORKING:
-		setWorking(true);
-		setFinished(false);
-		break;
-	case STATUS_FINISHED:
-		setWorking(false);
-		setFinished(true, ok, msg);
-		break;
-	}
-
-	mStatus = status;
+    switch (status)
+    {
+    case STATUS_READY:
+        setWorking(false);
+        setFinished(false);
+        break;
+    case STATUS_WORKING:
+        setWorking(true);
+        setFinished(false);
+        break;
+    case STATUS_FINISHED:
+        setWorking(false);
+        setFinished(true, ok, msg);
+        break;
+    }
+
+    mStatus = status;
 }
 
 // virtual
 void LLFloaterSnapshotBase::ImplBase::setNeedRefresh(bool need)
 {
-	if (!mFloater) return;
+    if (!mFloater) return;
 
-	// Don't display the "Refresh to save" message if we're in auto-refresh mode.
-	if (gSavedSettings.getBOOL("AutoSnapshot"))
-	{
-		need = false;
-	}
+    // Don't display the "Refresh to save" message if we're in auto-refresh mode.
+    if (gSavedSettings.getBOOL("AutoSnapshot"))
+    {
+        need = false;
+    }
 
-	mFloater->setRefreshLabelVisible(need);
-	mNeedRefresh = need;
+    mFloater->setRefreshLabelVisible(need);
+    mNeedRefresh = need;
 }
 
 // virtual
 void LLFloaterSnapshotBase::ImplBase::checkAutoSnapshot(LLSnapshotLivePreview* previewp, BOOL update_thumbnail)
 {
-	if (previewp)
-	{
-		BOOL autosnap = gSavedSettings.getBOOL("AutoSnapshot");
-		LL_DEBUGS() << "updating " << (autosnap ? "snapshot" : "thumbnail") << LL_ENDL;
-		previewp->updateSnapshot(autosnap, update_thumbnail, autosnap ? AUTO_SNAPSHOT_TIME_DELAY : 0.f);
-	}
+    if (previewp)
+    {
+        BOOL autosnap = gSavedSettings.getBOOL("AutoSnapshot");
+        LL_DEBUGS() << "updating " << (autosnap ? "snapshot" : "thumbnail") << LL_ENDL;
+        previewp->updateSnapshot(autosnap, update_thumbnail, autosnap ? AUTO_SNAPSHOT_TIME_DELAY : 0.f);
+    }
 }
 
 // static
 void LLFloaterSnapshotBase::ImplBase::onClickNewSnapshot(void* data)
 {
-	LLFloaterSnapshotBase* floater = (LLFloaterSnapshotBase *)data;
-	LLSnapshotLivePreview* previewp = floater->getPreviewView();
-	if (previewp)
-	{
-		floater->impl->setStatus(ImplBase::STATUS_READY);
-		LL_DEBUGS() << "updating snapshot" << LL_ENDL;
-		previewp->mForceUpdateSnapshot = TRUE;
-	}
+    LLFloaterSnapshotBase* floater = (LLFloaterSnapshotBase *)data;
+    LLSnapshotLivePreview* previewp = floater->getPreviewView();
+    if (previewp)
+    {
+        floater->impl->setStatus(ImplBase::STATUS_READY);
+        LL_DEBUGS() << "updating snapshot" << LL_ENDL;
+        previewp->mForceUpdateSnapshot = TRUE;
+    }
 }
 
 // static
 void LLFloaterSnapshotBase::ImplBase::onClickAutoSnap(LLUICtrl *ctrl, void* data)
 {
-	LLCheckBoxCtrl *check = (LLCheckBoxCtrl *)ctrl;
-	gSavedSettings.setBOOL( "AutoSnapshot", check->get() );
+    LLCheckBoxCtrl *check = (LLCheckBoxCtrl *)ctrl;
+    gSavedSettings.setBOOL( "AutoSnapshot", check->get() );
 
-	LLFloaterSnapshotBase *view = (LLFloaterSnapshotBase *)data;
-	if (view)
-	{
-		view->impl->checkAutoSnapshot(view->getPreviewView());
-		view->impl->updateControls(view);
-	}
+    LLFloaterSnapshotBase *view = (LLFloaterSnapshotBase *)data;
+    if (view)
+    {
+        view->impl->checkAutoSnapshot(view->getPreviewView());
+        view->impl->updateControls(view);
+    }
 }
 
 // static
@@ -484,457 +484,457 @@ void LLFloaterSnapshotBase::ImplBase::onClickNoPost(LLUICtrl *ctrl, void* data)
 // static
 void LLFloaterSnapshotBase::ImplBase::onClickFilter(LLUICtrl *ctrl, void* data)
 {
-	LLFloaterSnapshotBase *view = (LLFloaterSnapshotBase *)data;
-	if (view)
-	{
-		view->impl->updateControls(view);
-		LLSnapshotLivePreview* previewp = view->getPreviewView();
+    LLFloaterSnapshotBase *view = (LLFloaterSnapshotBase *)data;
+    if (view)
+    {
+        view->impl->updateControls(view);
+        LLSnapshotLivePreview* previewp = view->getPreviewView();
         if (previewp)
         {
-			view->impl->checkAutoSnapshot(previewp);
+            view->impl->checkAutoSnapshot(previewp);
             // Note : index 0 of the filter drop down is assumed to be "No filter" in whichever locale
             LLComboBox* filterbox = static_cast<LLComboBox *>(view->getChild<LLComboBox>("filters_combobox"));
             std::string filter_name = (filterbox->getCurrentIndex() ? filterbox->getSimple() : "");
             previewp->setFilter(filter_name);
             previewp->updateSnapshot(TRUE);
         }
-	}
+    }
 }
 
 // static
 void LLFloaterSnapshotBase::ImplBase::onClickUICheck(LLUICtrl *ctrl, void* data)
 {
-	LLCheckBoxCtrl *check = (LLCheckBoxCtrl *)ctrl;
-	gSavedSettings.setBOOL( "RenderUIInSnapshot", check->get() );
-	
-	LLFloaterSnapshot *view = (LLFloaterSnapshot *)data;
-	if (view)
-	{
-		LLSnapshotLivePreview* previewp = view->getPreviewView();
-		if(previewp)
-		{
-			previewp->updateSnapshot(TRUE, TRUE);
-		}
-		view->impl->updateControls(view);
-	}
+    LLCheckBoxCtrl *check = (LLCheckBoxCtrl *)ctrl;
+    gSavedSettings.setBOOL( "RenderUIInSnapshot", check->get() );
+
+    LLFloaterSnapshot *view = (LLFloaterSnapshot *)data;
+    if (view)
+    {
+        LLSnapshotLivePreview* previewp = view->getPreviewView();
+        if(previewp)
+        {
+            previewp->updateSnapshot(TRUE, TRUE);
+        }
+        view->impl->updateControls(view);
+    }
 }
 
 // static
 void LLFloaterSnapshotBase::ImplBase::onClickHUDCheck(LLUICtrl *ctrl, void* data)
 {
-	LLCheckBoxCtrl *check = (LLCheckBoxCtrl *)ctrl;
-	gSavedSettings.setBOOL( "RenderHUDInSnapshot", check->get() );
-	
-	LLFloaterSnapshot *view = (LLFloaterSnapshot *)data;
-	if (view)
-	{
-		LLSnapshotLivePreview* previewp = view->getPreviewView();
-		if(previewp)
-		{
-			previewp->updateSnapshot(TRUE, TRUE);
-		}
-		view->impl->updateControls(view);
-	}
+    LLCheckBoxCtrl *check = (LLCheckBoxCtrl *)ctrl;
+    gSavedSettings.setBOOL( "RenderHUDInSnapshot", check->get() );
+
+    LLFloaterSnapshot *view = (LLFloaterSnapshot *)data;
+    if (view)
+    {
+        LLSnapshotLivePreview* previewp = view->getPreviewView();
+        if(previewp)
+        {
+            previewp->updateSnapshot(TRUE, TRUE);
+        }
+        view->impl->updateControls(view);
+    }
 }
 
 void LLFloaterSnapshot::Impl::applyKeepAspectCheck(LLFloaterSnapshotBase* view, BOOL checked)
 {
-	gSavedSettings.setBOOL("KeepAspectForSnapshot", checked);
+    gSavedSettings.setBOOL("KeepAspectForSnapshot", checked);
 
-	if (view)
-	{
-		LLPanelSnapshot* active_panel = getActivePanel(view);
-		if (checked && active_panel)
-		{
-			LLComboBox* combo = view->getChild<LLComboBox>(active_panel->getImageSizeComboName());
-			combo->setCurrentByIndex(combo->getItemCount() - 1); // "custom" is always the last index
-		}
+    if (view)
+    {
+        LLPanelSnapshot* active_panel = getActivePanel(view);
+        if (checked && active_panel)
+        {
+            LLComboBox* combo = view->getChild<LLComboBox>(active_panel->getImageSizeComboName());
+            combo->setCurrentByIndex(combo->getItemCount() - 1); // "custom" is always the last index
+        }
 
-		LLSnapshotLivePreview* previewp = getPreviewView() ;
-		if(previewp)
-		{
-			previewp->mKeepAspectRatio = gSavedSettings.getBOOL("KeepAspectForSnapshot") ;
+        LLSnapshotLivePreview* previewp = getPreviewView() ;
+        if(previewp)
+        {
+            previewp->mKeepAspectRatio = gSavedSettings.getBOOL("KeepAspectForSnapshot") ;
 
-			S32 w, h ;
-			previewp->getSize(w, h) ;
-			updateSpinners(view, previewp, w, h, TRUE); // may change w and h
+            S32 w, h ;
+            previewp->getSize(w, h) ;
+            updateSpinners(view, previewp, w, h, TRUE); // may change w and h
 
-			LL_DEBUGS() << "updating thumbnail" << LL_ENDL;
-			previewp->setSize(w, h) ;
-			previewp->updateSnapshot(TRUE);
-			checkAutoSnapshot(previewp, TRUE);
-		}
-	}
+            LL_DEBUGS() << "updating thumbnail" << LL_ENDL;
+            previewp->setSize(w, h) ;
+            previewp->updateSnapshot(TRUE);
+            checkAutoSnapshot(previewp, TRUE);
+        }
+    }
 }
 
 // static
 void LLFloaterSnapshotBase::ImplBase::onCommitFreezeFrame(LLUICtrl* ctrl, void* data)
 {
-	LLCheckBoxCtrl* check_box = (LLCheckBoxCtrl*)ctrl;
-	LLFloaterSnapshotBase *view = (LLFloaterSnapshotBase *)data;
-	LLSnapshotLivePreview* previewp = view->getPreviewView();
-		
-	if (!view || !check_box || !previewp)
-	{
-		return;
-	}
+    LLCheckBoxCtrl* check_box = (LLCheckBoxCtrl*)ctrl;
+    LLFloaterSnapshotBase *view = (LLFloaterSnapshotBase *)data;
+    LLSnapshotLivePreview* previewp = view->getPreviewView();
+
+    if (!view || !check_box || !previewp)
+    {
+        return;
+    }
 
-	gSavedSettings.setBOOL("UseFreezeFrame", check_box->get());
+    gSavedSettings.setBOOL("UseFreezeFrame", check_box->get());
 
-	if (check_box->get())
-	{
-		previewp->prepareFreezeFrame();
-	}
+    if (check_box->get())
+    {
+        previewp->prepareFreezeFrame();
+    }
 
-	view->impl->updateLayout(view);
+    view->impl->updateLayout(view);
 }
 
 void LLFloaterSnapshot::Impl::checkAspectRatio(LLFloaterSnapshotBase *view, S32 index)
 {
-	LLSnapshotLivePreview *previewp = getPreviewView() ;
-
-	// Don't round texture sizes; textures are commonly stretched in world, profiles, etc and need to be "squashed" during upload, not cropped here
-	if (LLSnapshotModel::SNAPSHOT_TEXTURE == getActiveSnapshotType(view))
-	{
-		previewp->mKeepAspectRatio = FALSE ;
-		return ;
-	}
-
-	BOOL keep_aspect = FALSE, enable_cb = FALSE;
-
-	if (0 == index) // current window size
-	{
-		enable_cb = FALSE;
-		keep_aspect = TRUE;
-	}
-	else if (-1 == index) // custom
-	{
-		enable_cb = TRUE;
-		keep_aspect = gSavedSettings.getBOOL("KeepAspectForSnapshot");
-	}
-	else // predefined resolution
-	{
-		enable_cb = FALSE;
-		keep_aspect = FALSE;
-	}
-
-	view->impl->mAspectRatioCheckOff = !enable_cb;
-
-	if (previewp)
-	{
-		previewp->mKeepAspectRatio = keep_aspect;
-	}
+    LLSnapshotLivePreview *previewp = getPreviewView() ;
+
+    // Don't round texture sizes; textures are commonly stretched in world, profiles, etc and need to be "squashed" during upload, not cropped here
+    if (LLSnapshotModel::SNAPSHOT_TEXTURE == getActiveSnapshotType(view))
+    {
+        previewp->mKeepAspectRatio = FALSE ;
+        return ;
+    }
+
+    BOOL keep_aspect = FALSE, enable_cb = FALSE;
+
+    if (0 == index) // current window size
+    {
+        enable_cb = FALSE;
+        keep_aspect = TRUE;
+    }
+    else if (-1 == index) // custom
+    {
+        enable_cb = TRUE;
+        keep_aspect = gSavedSettings.getBOOL("KeepAspectForSnapshot");
+    }
+    else // predefined resolution
+    {
+        enable_cb = FALSE;
+        keep_aspect = FALSE;
+    }
+
+    view->impl->mAspectRatioCheckOff = !enable_cb;
+
+    if (previewp)
+    {
+        previewp->mKeepAspectRatio = keep_aspect;
+    }
 }
 
 // Show/hide upload progress indicators.
 void LLFloaterSnapshotBase::ImplBase::setWorking(bool working)
 {
-	LLUICtrl* working_lbl = mFloater->getChild<LLUICtrl>("working_lbl");
-	working_lbl->setVisible(working);
-	mFloater->getChild<LLUICtrl>("working_indicator")->setVisible(working);
+    LLUICtrl* working_lbl = mFloater->getChild<LLUICtrl>("working_lbl");
+    working_lbl->setVisible(working);
+    mFloater->getChild<LLUICtrl>("working_indicator")->setVisible(working);
 
-	if (working)
-	{
-		const std::string panel_name = getActivePanel(mFloater, false)->getName();
-		const std::string prefix = panel_name.substr(getSnapshotPanelPrefix().size());
-		std::string progress_text = mFloater->getString(prefix + "_" + "progress_str");
-		working_lbl->setValue(progress_text);
-	}
+    if (working)
+    {
+        const std::string panel_name = getActivePanel(mFloater, false)->getName();
+        const std::string prefix = panel_name.substr(getSnapshotPanelPrefix().size());
+        std::string progress_text = mFloater->getString(prefix + "_" + "progress_str");
+        working_lbl->setValue(progress_text);
+    }
 
-	// All controls should be disabled while posting.
-	mFloater->setCtrlsEnabled(!working);
-	LLPanelSnapshot* active_panel = getActivePanel(mFloater);
-	if (active_panel)
-	{
-		active_panel->enableControls(!working);
-	}
+    // All controls should be disabled while posting.
+    mFloater->setCtrlsEnabled(!working);
+    LLPanelSnapshot* active_panel = getActivePanel(mFloater);
+    if (active_panel)
+    {
+        active_panel->enableControls(!working);
+    }
 }
 
 //virtual
 std::string LLFloaterSnapshot::Impl::getSnapshotPanelPrefix()
 {
-	return "panel_snapshot_";
+    return "panel_snapshot_";
 }
 
 // Show/hide upload status message.
 // virtual
 void LLFloaterSnapshot::Impl::setFinished(bool finished, bool ok, const std::string& msg)
 {
-	mFloater->setSuccessLabelPanelVisible(finished && ok);
-	mFloater->setFailureLabelPanelVisible(finished && !ok);
+    mFloater->setSuccessLabelPanelVisible(finished && ok);
+    mFloater->setFailureLabelPanelVisible(finished && !ok);
 
-	if (finished)
-	{
-		LLUICtrl* finished_lbl = mFloater->getChild<LLUICtrl>(ok ? "succeeded_lbl" : "failed_lbl");
-		std::string result_text = mFloater->getString(msg + "_" + (ok ? "succeeded_str" : "failed_str"));
-		finished_lbl->setValue(result_text);
-	}
+    if (finished)
+    {
+        LLUICtrl* finished_lbl = mFloater->getChild<LLUICtrl>(ok ? "succeeded_lbl" : "failed_lbl");
+        std::string result_text = mFloater->getString(msg + "_" + (ok ? "succeeded_str" : "failed_str"));
+        finished_lbl->setValue(result_text);
+    }
 }
 
 // Apply a new resolution selected from the given combobox.
 void LLFloaterSnapshot::Impl::updateResolution(LLUICtrl* ctrl, void* data, BOOL do_update)
 {
-	LLComboBox* combobox = (LLComboBox*)ctrl;
-	LLFloaterSnapshot *view = (LLFloaterSnapshot *)data;
-		
-	if (!view || !combobox)
-	{
-		llassert(view && combobox);
-		return;
-	}
-
-	std::string sdstring = combobox->getSelectedValue();
-	LLSD sdres;
-	std::stringstream sstream(sdstring);
-	LLSDSerialize::fromNotation(sdres, sstream, sdstring.size());
-		
-	S32 width = sdres[0];
-	S32 height = sdres[1];
-	
-	LLSnapshotLivePreview* previewp = getPreviewView();
-	if (previewp && combobox->getCurrentIndex() >= 0)
-	{
-		S32 original_width = 0 , original_height = 0 ;
-		previewp->getSize(original_width, original_height) ;
-		
-		if (gSavedSettings.getBOOL("RenderUIInSnapshot") || gSavedSettings.getBOOL("RenderHUDInSnapshot"))
-		{ //clamp snapshot resolution to window size when showing UI or HUD in snapshot
-			width = llmin(width, gViewerWindow->getWindowWidthRaw());
-			height = llmin(height, gViewerWindow->getWindowHeightRaw());
-		}
-
-		if (width == 0 || height == 0)
-		{
-			// take resolution from current window size
-			LL_DEBUGS() << "Setting preview res from window: " << gViewerWindow->getWindowWidthRaw() << "x" << gViewerWindow->getWindowHeightRaw() << LL_ENDL;
-			previewp->setSize(gViewerWindow->getWindowWidthRaw(), gViewerWindow->getWindowHeightRaw());
-		}
-		else if (width == -1 || height == -1)
-		{
-			// load last custom value
-			S32 new_width = 0, new_height = 0;
-			LLPanelSnapshot* spanel = getActivePanel(view);
-			if (spanel)
-			{
-				LL_DEBUGS() << "Loading typed res from panel " << spanel->getName() << LL_ENDL;
-				new_width = spanel->getTypedPreviewWidth();
-				new_height = spanel->getTypedPreviewHeight();
-
-				// Limit custom size for inventory snapshots to 512x512 px.
-				if (getActiveSnapshotType(view) == LLSnapshotModel::SNAPSHOT_TEXTURE)
-				{
-					new_width = llmin(new_width, MAX_TEXTURE_SIZE);
-					new_height = llmin(new_height, MAX_TEXTURE_SIZE);
-				}
-			}
-			else
-			{
-				LL_DEBUGS() << "No custom res chosen, setting preview res from window: "
-					<< gViewerWindow->getWindowWidthRaw() << "x" << gViewerWindow->getWindowHeightRaw() << LL_ENDL;
-				new_width = gViewerWindow->getWindowWidthRaw();
-				new_height = gViewerWindow->getWindowHeightRaw();
-			}
-
-			llassert(new_width > 0 && new_height > 0);
-			previewp->setSize(new_width, new_height);
-		}
-		else
-		{
-			// use the resolution from the selected pre-canned drop-down choice
-			LL_DEBUGS() << "Setting preview res selected from combo: " << width << "x" << height << LL_ENDL;
-			previewp->setSize(width, height);
-		}
-
-		checkAspectRatio(view, width) ;
-
-		previewp->getSize(width, height);
-
-		// We use the height spinner here because we come here via the aspect ratio
-		// checkbox as well and we want height always changing to width by default.
-		// If we use the width spinner we would change width according to height by
-		// default, that is not what we want.
-		updateSpinners(view, previewp, width, height, !getHeightSpinner(view)->isDirty()); // may change width and height
-		
-		if(getWidthSpinner(view)->getValue().asInteger() != width || getHeightSpinner(view)->getValue().asInteger() != height)
-		{
-			getWidthSpinner(view)->setValue(width);
-			getHeightSpinner(view)->setValue(height);
-			if (getActiveSnapshotType(view) == LLSnapshotModel::SNAPSHOT_TEXTURE)
-			{
-				getWidthSpinner(view)->setIncrement(width >> 1);
-				getHeightSpinner(view)->setIncrement(height >> 1);
-			}
-		}
-
-		if(original_width != width || original_height != height)
-		{
-			previewp->setSize(width, height);
-
-			// hide old preview as the aspect ratio could be wrong
-			checkAutoSnapshot(previewp, FALSE);
-			LL_DEBUGS() << "updating thumbnail" << LL_ENDL;
-			// Don't update immediately, give window chance to redraw
-			getPreviewView()->updateSnapshot(TRUE, FALSE, 1.f);
-			if(do_update)
-			{
-				LL_DEBUGS() << "Will update controls" << LL_ENDL;
-				updateControls(view);
-			}
-		}
-	}
+    LLComboBox* combobox = (LLComboBox*)ctrl;
+    LLFloaterSnapshot *view = (LLFloaterSnapshot *)data;
+
+    if (!view || !combobox)
+    {
+        llassert(view && combobox);
+        return;
+    }
+
+    std::string sdstring = combobox->getSelectedValue();
+    LLSD sdres;
+    std::stringstream sstream(sdstring);
+    LLSDSerialize::fromNotation(sdres, sstream, sdstring.size());
+
+    S32 width = sdres[0];
+    S32 height = sdres[1];
+
+    LLSnapshotLivePreview* previewp = getPreviewView();
+    if (previewp && combobox->getCurrentIndex() >= 0)
+    {
+        S32 original_width = 0 , original_height = 0 ;
+        previewp->getSize(original_width, original_height) ;
+
+        if (gSavedSettings.getBOOL("RenderUIInSnapshot") || gSavedSettings.getBOOL("RenderHUDInSnapshot"))
+        { //clamp snapshot resolution to window size when showing UI or HUD in snapshot
+            width = llmin(width, gViewerWindow->getWindowWidthRaw());
+            height = llmin(height, gViewerWindow->getWindowHeightRaw());
+        }
+
+        if (width == 0 || height == 0)
+        {
+            // take resolution from current window size
+            LL_DEBUGS() << "Setting preview res from window: " << gViewerWindow->getWindowWidthRaw() << "x" << gViewerWindow->getWindowHeightRaw() << LL_ENDL;
+            previewp->setSize(gViewerWindow->getWindowWidthRaw(), gViewerWindow->getWindowHeightRaw());
+        }
+        else if (width == -1 || height == -1)
+        {
+            // load last custom value
+            S32 new_width = 0, new_height = 0;
+            LLPanelSnapshot* spanel = getActivePanel(view);
+            if (spanel)
+            {
+                LL_DEBUGS() << "Loading typed res from panel " << spanel->getName() << LL_ENDL;
+                new_width = spanel->getTypedPreviewWidth();
+                new_height = spanel->getTypedPreviewHeight();
+
+                // Limit custom size for inventory snapshots to 512x512 px.
+                if (getActiveSnapshotType(view) == LLSnapshotModel::SNAPSHOT_TEXTURE)
+                {
+                    new_width = llmin(new_width, MAX_TEXTURE_SIZE);
+                    new_height = llmin(new_height, MAX_TEXTURE_SIZE);
+                }
+            }
+            else
+            {
+                LL_DEBUGS() << "No custom res chosen, setting preview res from window: "
+                    << gViewerWindow->getWindowWidthRaw() << "x" << gViewerWindow->getWindowHeightRaw() << LL_ENDL;
+                new_width = gViewerWindow->getWindowWidthRaw();
+                new_height = gViewerWindow->getWindowHeightRaw();
+            }
+
+            llassert(new_width > 0 && new_height > 0);
+            previewp->setSize(new_width, new_height);
+        }
+        else
+        {
+            // use the resolution from the selected pre-canned drop-down choice
+            LL_DEBUGS() << "Setting preview res selected from combo: " << width << "x" << height << LL_ENDL;
+            previewp->setSize(width, height);
+        }
+
+        checkAspectRatio(view, width) ;
+
+        previewp->getSize(width, height);
+
+        // We use the height spinner here because we come here via the aspect ratio
+        // checkbox as well and we want height always changing to width by default.
+        // If we use the width spinner we would change width according to height by
+        // default, that is not what we want.
+        updateSpinners(view, previewp, width, height, !getHeightSpinner(view)->isDirty()); // may change width and height
+
+        if(getWidthSpinner(view)->getValue().asInteger() != width || getHeightSpinner(view)->getValue().asInteger() != height)
+        {
+            getWidthSpinner(view)->setValue(width);
+            getHeightSpinner(view)->setValue(height);
+            if (getActiveSnapshotType(view) == LLSnapshotModel::SNAPSHOT_TEXTURE)
+            {
+                getWidthSpinner(view)->setIncrement(width >> 1);
+                getHeightSpinner(view)->setIncrement(height >> 1);
+            }
+        }
+
+        if(original_width != width || original_height != height)
+        {
+            previewp->setSize(width, height);
+
+            // hide old preview as the aspect ratio could be wrong
+            checkAutoSnapshot(previewp, FALSE);
+            LL_DEBUGS() << "updating thumbnail" << LL_ENDL;
+            // Don't update immediately, give window chance to redraw
+            getPreviewView()->updateSnapshot(TRUE, FALSE, 1.f);
+            if(do_update)
+            {
+                LL_DEBUGS() << "Will update controls" << LL_ENDL;
+                updateControls(view);
+            }
+        }
+    }
 }
 
 // static
 void LLFloaterSnapshot::Impl::onCommitLayerTypes(LLUICtrl* ctrl, void*data)
 {
-	LLComboBox* combobox = (LLComboBox*)ctrl;
+    LLComboBox* combobox = (LLComboBox*)ctrl;
 
-	LLFloaterSnapshot *view = (LLFloaterSnapshot *)data;
-		
-	if (view)
-	{
-		LLSnapshotLivePreview* previewp = view->getPreviewView();
-		if (previewp)
-		{
-			previewp->setSnapshotBufferType((LLSnapshotModel::ESnapshotLayerType)combobox->getCurrentIndex());
-		}
-		view->impl->checkAutoSnapshot(previewp, TRUE);
-		previewp->updateSnapshot(TRUE, TRUE);
-	}
+    LLFloaterSnapshot *view = (LLFloaterSnapshot *)data;
+
+    if (view)
+    {
+        LLSnapshotLivePreview* previewp = view->getPreviewView();
+        if (previewp)
+        {
+            previewp->setSnapshotBufferType((LLSnapshotModel::ESnapshotLayerType)combobox->getCurrentIndex());
+        }
+        view->impl->checkAutoSnapshot(previewp, TRUE);
+        previewp->updateSnapshot(TRUE, TRUE);
+    }
 }
 
 void LLFloaterSnapshot::Impl::onImageQualityChange(LLFloaterSnapshotBase* view, S32 quality_val)
 {
-	LLSnapshotLivePreview* previewp = getPreviewView();
-	if (previewp)
-	{
-		previewp->setSnapshotQuality(quality_val);
-	}
+    LLSnapshotLivePreview* previewp = getPreviewView();
+    if (previewp)
+    {
+        previewp->setSnapshotQuality(quality_val);
+    }
 }
 
 void LLFloaterSnapshot::Impl::onImageFormatChange(LLFloaterSnapshotBase* view)
 {
-	if (view)
-	{
-		gSavedSettings.setS32("SnapshotFormat", getImageFormat(view));
-		LL_DEBUGS() << "image format changed, updating snapshot" << LL_ENDL;
-		getPreviewView()->updateSnapshot(TRUE);
-		updateControls(view);
-	}
+    if (view)
+    {
+        gSavedSettings.setS32("SnapshotFormat", getImageFormat(view));
+        LL_DEBUGS() << "image format changed, updating snapshot" << LL_ENDL;
+        getPreviewView()->updateSnapshot(TRUE);
+        updateControls(view);
+    }
 }
 
 // Sets the named size combo to "custom" mode.
 void LLFloaterSnapshot::Impl::comboSetCustom(LLFloaterSnapshotBase* floater, const std::string& comboname)
 {
-	LLComboBox* combo = floater->getChild<LLComboBox>(comboname);
-	combo->setCurrentByIndex(combo->getItemCount() - 1); // "custom" is always the last index
-	checkAspectRatio(floater, -1); // -1 means custom
+    LLComboBox* combo = floater->getChild<LLComboBox>(comboname);
+    combo->setCurrentByIndex(combo->getItemCount() - 1); // "custom" is always the last index
+    checkAspectRatio(floater, -1); // -1 means custom
 }
 
 // Update supplied width and height according to the constrain proportions flag; limit them by max_val.
 BOOL LLFloaterSnapshot::Impl::checkImageSize(LLSnapshotLivePreview* previewp, S32& width, S32& height, BOOL isWidthChanged, S32 max_value)
 {
-	S32 w = width ;
-	S32 h = height ;
-
-	if(previewp && previewp->mKeepAspectRatio)
-	{
-		if(gViewerWindow->getWindowWidthRaw() < 1 || gViewerWindow->getWindowHeightRaw() < 1)
-		{
-			return FALSE ;
-		}
-
-		//aspect ratio of the current window
-		F32 aspect_ratio = (F32)gViewerWindow->getWindowWidthRaw() / gViewerWindow->getWindowHeightRaw() ;
-
-		//change another value proportionally
-		if(isWidthChanged)
-		{
-			height = ll_round(width / aspect_ratio) ;
-		}
-		else
-		{
-			width = ll_round(height * aspect_ratio) ;
-		}
-
-		//bound w/h by the max_value
-		if(width > max_value || height > max_value)
-		{
-			if(width > height)
-			{
-				width = max_value ;
-				height = (S32)(width / aspect_ratio) ;
-			}
-			else
-			{
-				height = max_value ;
-				width = (S32)(height * aspect_ratio) ;
-			}
-		}
-	}
-
-	return (w != width || h != height) ;
+    S32 w = width ;
+    S32 h = height ;
+
+    if(previewp && previewp->mKeepAspectRatio)
+    {
+        if(gViewerWindow->getWindowWidthRaw() < 1 || gViewerWindow->getWindowHeightRaw() < 1)
+        {
+            return FALSE ;
+        }
+
+        //aspect ratio of the current window
+        F32 aspect_ratio = (F32)gViewerWindow->getWindowWidthRaw() / gViewerWindow->getWindowHeightRaw() ;
+
+        //change another value proportionally
+        if(isWidthChanged)
+        {
+            height = ll_round(width / aspect_ratio) ;
+        }
+        else
+        {
+            width = ll_round(height * aspect_ratio) ;
+        }
+
+        //bound w/h by the max_value
+        if(width > max_value || height > max_value)
+        {
+            if(width > height)
+            {
+                width = max_value ;
+                height = (S32)(width / aspect_ratio) ;
+            }
+            else
+            {
+                height = max_value ;
+                width = (S32)(height * aspect_ratio) ;
+            }
+        }
+    }
+
+    return (w != width || h != height) ;
 }
 
 void LLFloaterSnapshot::Impl::setImageSizeSpinnersValues(LLFloaterSnapshotBase* view, S32 width, S32 height)
 {
-	getWidthSpinner(view)->forceSetValue(width);
-	getHeightSpinner(view)->forceSetValue(height);
-	if (getActiveSnapshotType(view) == LLSnapshotModel::SNAPSHOT_TEXTURE)
-	{
-		getWidthSpinner(view)->setIncrement(width >> 1);
-		getHeightSpinner(view)->setIncrement(height >> 1);
-	}
+    getWidthSpinner(view)->forceSetValue(width);
+    getHeightSpinner(view)->forceSetValue(height);
+    if (getActiveSnapshotType(view) == LLSnapshotModel::SNAPSHOT_TEXTURE)
+    {
+        getWidthSpinner(view)->setIncrement(width >> 1);
+        getHeightSpinner(view)->setIncrement(height >> 1);
+    }
 }
 
 void LLFloaterSnapshot::Impl::updateSpinners(LLFloaterSnapshotBase* view, LLSnapshotLivePreview* previewp, S32& width, S32& height, BOOL is_width_changed)
 {
-	getWidthSpinner(view)->resetDirty();
-	getHeightSpinner(view)->resetDirty();
-	if (checkImageSize(previewp, width, height, is_width_changed, previewp->getMaxImageSize()))
-	{
-		setImageSizeSpinnersValues(view, width, height);
-	}
+    getWidthSpinner(view)->resetDirty();
+    getHeightSpinner(view)->resetDirty();
+    if (checkImageSize(previewp, width, height, is_width_changed, previewp->getMaxImageSize()))
+    {
+        setImageSizeSpinnersValues(view, width, height);
+    }
 }
 
 void LLFloaterSnapshot::Impl::applyCustomResolution(LLFloaterSnapshotBase* view, S32 w, S32 h)
 {
-	LL_DEBUGS() << "applyCustomResolution(" << w << ", " << h << ")" << LL_ENDL;
-	if (!view) return;
-
-	LLSnapshotLivePreview* previewp = getPreviewView();
-	if (previewp)
-	{
-		S32 curw,curh;
-		previewp->getSize(curw, curh);
+    LL_DEBUGS() << "applyCustomResolution(" << w << ", " << h << ")" << LL_ENDL;
+    if (!view) return;
 
-		if (w != curw || h != curh)
-		{
-			//if to upload a snapshot, process spinner input in a special way.
-			previewp->setMaxImageSize((S32) getWidthSpinner(view)->getMaxValue()) ;
+    LLSnapshotLivePreview* previewp = getPreviewView();
+    if (previewp)
+    {
+        S32 curw,curh;
+        previewp->getSize(curw, curh);
 
-			previewp->setSize(w,h);
-			checkAutoSnapshot(previewp, FALSE);
-			comboSetCustom(view, "profile_size_combo");
-			comboSetCustom(view, "postcard_size_combo");
-			comboSetCustom(view, "texture_size_combo");
-			comboSetCustom(view, "local_size_combo");
-			LL_DEBUGS() << "applied custom resolution, updating thumbnail" << LL_ENDL;
-			previewp->updateSnapshot(TRUE);
-		}
-	}
+        if (w != curw || h != curh)
+        {
+            //if to upload a snapshot, process spinner input in a special way.
+            previewp->setMaxImageSize((S32) getWidthSpinner(view)->getMaxValue()) ;
+
+            previewp->setSize(w,h);
+            checkAutoSnapshot(previewp, FALSE);
+            comboSetCustom(view, "profile_size_combo");
+            comboSetCustom(view, "postcard_size_combo");
+            comboSetCustom(view, "texture_size_combo");
+            comboSetCustom(view, "local_size_combo");
+            LL_DEBUGS() << "applied custom resolution, updating thumbnail" << LL_ENDL;
+            previewp->updateSnapshot(TRUE);
+        }
+    }
 }
 
 // static
 void LLFloaterSnapshot::Impl::onSnapshotUploadFinished(LLFloaterSnapshotBase* floater, bool status)
 {
-	floater->impl->setStatus(STATUS_FINISHED, status, "profile");
+    floater->impl->setStatus(STATUS_FINISHED, status, "profile");
 }
 
 // static
 void LLFloaterSnapshot::Impl::onSendingPostcardFinished(LLFloaterSnapshotBase* floater, bool status)
 {
-	floater->impl->setStatus(STATUS_FINISHED, status, "postcard");
+    floater->impl->setStatus(STATUS_FINISHED, status, "postcard");
 }
 
 ///----------------------------------------------------------------------------
@@ -944,26 +944,26 @@ void LLFloaterSnapshot::Impl::onSendingPostcardFinished(LLFloaterSnapshotBase* f
 // Default constructor
 LLFloaterSnapshotBase::LLFloaterSnapshotBase(const LLSD& key)
     : LLFloater(key),
-	  mRefreshBtn(NULL),
-	  mRefreshLabel(NULL),
-	  mSucceessLblPanel(NULL),
-	  mFailureLblPanel(NULL)
+      mRefreshBtn(NULL),
+      mRefreshLabel(NULL),
+      mSucceessLblPanel(NULL),
+      mFailureLblPanel(NULL)
 {
 }
 
 LLFloaterSnapshotBase::~LLFloaterSnapshotBase()
 {
-	if (impl->mPreviewHandle.get()) impl->mPreviewHandle.get()->die();
+    if (impl->mPreviewHandle.get()) impl->mPreviewHandle.get()->die();
 
-	//unfreeze everything else
-	gSavedSettings.setBOOL("FreezeTime", FALSE);
+    //unfreeze everything else
+    gSavedSettings.setBOOL("FreezeTime", FALSE);
 
-	if (impl->mLastToolset)
-	{
-		LLToolMgr::getInstance()->setCurrentToolset(impl->mLastToolset);
-	}
+    if (impl->mLastToolset)
+    {
+        LLToolMgr::getInstance()->setCurrentToolset(impl->mLastToolset);
+    }
 
-	delete impl;
+    delete impl;
 }
 
 ///----------------------------------------------------------------------------
@@ -974,7 +974,7 @@ LLFloaterSnapshotBase::~LLFloaterSnapshotBase()
 LLFloaterSnapshot::LLFloaterSnapshot(const LLSD& key)
     : LLFloaterSnapshotBase(key)
 {
-	impl = new Impl(this);
+    impl = new Impl(this);
 }
 
 LLFloaterSnapshot::~LLFloaterSnapshot()
@@ -984,29 +984,29 @@ LLFloaterSnapshot::~LLFloaterSnapshot()
 // virtual
 BOOL LLFloaterSnapshot::postBuild()
 {
-	mRefreshBtn = getChild<LLUICtrl>("new_snapshot_btn");
-	childSetAction("new_snapshot_btn", ImplBase::onClickNewSnapshot, this);
-	mRefreshLabel = getChild<LLUICtrl>("refresh_lbl");
-	mSucceessLblPanel = getChild<LLUICtrl>("succeeded_panel");
-	mFailureLblPanel = getChild<LLUICtrl>("failed_panel");
+    mRefreshBtn = getChild<LLUICtrl>("new_snapshot_btn");
+    childSetAction("new_snapshot_btn", ImplBase::onClickNewSnapshot, this);
+    mRefreshLabel = getChild<LLUICtrl>("refresh_lbl");
+    mSucceessLblPanel = getChild<LLUICtrl>("succeeded_panel");
+    mFailureLblPanel = getChild<LLUICtrl>("failed_panel");
 
-	childSetCommitCallback("ui_check", ImplBase::onClickUICheck, this);
-	getChild<LLUICtrl>("ui_check")->setValue(gSavedSettings.getBOOL("RenderUIInSnapshot"));
+    childSetCommitCallback("ui_check", ImplBase::onClickUICheck, this);
+    getChild<LLUICtrl>("ui_check")->setValue(gSavedSettings.getBOOL("RenderUIInSnapshot"));
 
-	childSetCommitCallback("hud_check", ImplBase::onClickHUDCheck, this);
-	getChild<LLUICtrl>("hud_check")->setValue(gSavedSettings.getBOOL("RenderHUDInSnapshot"));
+    childSetCommitCallback("hud_check", ImplBase::onClickHUDCheck, this);
+    getChild<LLUICtrl>("hud_check")->setValue(gSavedSettings.getBOOL("RenderHUDInSnapshot"));
 
-	((Impl*)impl)->setAspectRatioCheckboxValue(this, gSavedSettings.getBOOL("KeepAspectForSnapshot"));
+    ((Impl*)impl)->setAspectRatioCheckboxValue(this, gSavedSettings.getBOOL("KeepAspectForSnapshot"));
 
-	childSetCommitCallback("layer_types", Impl::onCommitLayerTypes, this);
-	getChild<LLUICtrl>("layer_types")->setValue("colors");
-	getChildView("layer_types")->setEnabled(FALSE);
+    childSetCommitCallback("layer_types", Impl::onCommitLayerTypes, this);
+    getChild<LLUICtrl>("layer_types")->setValue("colors");
+    getChildView("layer_types")->setEnabled(FALSE);
 
-	getChild<LLUICtrl>("freeze_frame_check")->setValue(gSavedSettings.getBOOL("UseFreezeFrame"));
-	childSetCommitCallback("freeze_frame_check", ImplBase::onCommitFreezeFrame, this);
+    getChild<LLUICtrl>("freeze_frame_check")->setValue(gSavedSettings.getBOOL("UseFreezeFrame"));
+    childSetCommitCallback("freeze_frame_check", ImplBase::onCommitFreezeFrame, this);
 
-	getChild<LLUICtrl>("auto_snapshot_check")->setValue(gSavedSettings.getBOOL("AutoSnapshot"));
-	childSetCommitCallback("auto_snapshot_check", ImplBase::onClickAutoSnap, this);
+    getChild<LLUICtrl>("auto_snapshot_check")->setValue(gSavedSettings.getBOOL("AutoSnapshot"));
+    childSetCommitCallback("auto_snapshot_check", ImplBase::onClickAutoSnap, this);
 
     getChild<LLUICtrl>("no_post_check")->setValue(gSavedSettings.getBOOL("RenderSnapshotNoPost"));
     childSetCommitCallback("no_post_check", ImplBase::onClickNoPost, this);
@@ -1018,130 +1018,130 @@ BOOL LLFloaterSnapshot::postBuild()
     getChild<LLTextBox>("360_label")->setShowCursorHand(false);
     getChild<LLTextBox>("360_label")->setClickedCallback(boost::bind(&LLFloaterSnapshot::on360Snapshot, this));
 
-	// Filters
-	LLComboBox* filterbox = getChild<LLComboBox>("filters_combobox");
-	std::vector<std::string> filter_list = LLImageFiltersManager::getInstance()->getFiltersList();
-	for (U32 i = 0; i < filter_list.size(); i++)
-	{
-		filterbox->add(filter_list[i]);
-	}
-	childSetCommitCallback("filters_combobox", ImplBase::onClickFilter, this);
-    
-	LLWebProfile::setImageUploadResultCallback(boost::bind(&Impl::onSnapshotUploadFinished, this, _1));
-	LLPostCard::setPostResultCallback(boost::bind(&Impl::onSendingPostcardFinished, this, _1));
-
-	mThumbnailPlaceholder = getChild<LLUICtrl>("thumbnail_placeholder");
-
-	// create preview window
-	LLRect full_screen_rect = getRootView()->getRect();
-	LLSnapshotLivePreview::Params p;
-	p.rect(full_screen_rect);
-	LLSnapshotLivePreview* previewp = new LLSnapshotLivePreview(p);
-	LLView* parent_view = gSnapshotFloaterView->getParent();
-	
-	parent_view->removeChild(gSnapshotFloaterView);
-	// make sure preview is below snapshot floater
-	parent_view->addChild(previewp);
-	parent_view->addChild(gSnapshotFloaterView);
-	
-	//move snapshot floater to special purpose snapshotfloaterview
-	gFloaterView->removeChild(this);
-	gSnapshotFloaterView->addChild(this);
-
-	// Pre-select "Current Window" resolution.
-	getChild<LLComboBox>("profile_size_combo")->selectNthItem(0);
-	getChild<LLComboBox>("postcard_size_combo")->selectNthItem(0);
-	getChild<LLComboBox>("texture_size_combo")->selectNthItem(0);
-	getChild<LLComboBox>("local_size_combo")->selectNthItem(8);
-	getChild<LLComboBox>("local_format_combo")->selectNthItem(0);
-
-	impl->mPreviewHandle = previewp->getHandle();
-    previewp->setContainer(this);
-	impl->updateControls(this);
-	impl->setAdvanced(gSavedSettings.getBOOL("AdvanceSnapshot"));
-	impl->updateLayout(this);
-	
+    // Filters
+    LLComboBox* filterbox = getChild<LLComboBox>("filters_combobox");
+    std::vector<std::string> filter_list = LLImageFiltersManager::getInstance()->getFiltersList();
+    for (U32 i = 0; i < filter_list.size(); i++)
+    {
+        filterbox->add(filter_list[i]);
+    }
+    childSetCommitCallback("filters_combobox", ImplBase::onClickFilter, this);
 
-	previewp->setThumbnailPlaceholderRect(getThumbnailPlaceholderRect());
+    LLWebProfile::setImageUploadResultCallback(boost::bind(&Impl::onSnapshotUploadFinished, this, _1));
+    LLPostCard::setPostResultCallback(boost::bind(&Impl::onSendingPostcardFinished, this, _1));
 
-	return TRUE;
-}
+    mThumbnailPlaceholder = getChild<LLUICtrl>("thumbnail_placeholder");
 
-// virtual
-void LLFloaterSnapshotBase::draw()
-{
-	LLSnapshotLivePreview* previewp = getPreviewView();
+    // create preview window
+    LLRect full_screen_rect = getRootView()->getRect();
+    LLSnapshotLivePreview::Params p;
+    p.rect(full_screen_rect);
+    LLSnapshotLivePreview* previewp = new LLSnapshotLivePreview(p);
+    LLView* parent_view = gSnapshotFloaterView->getParent();
 
-	if (previewp && (previewp->isSnapshotActive() || previewp->getThumbnailLock()))
-	{
-		// don't render snapshot window in snapshot, even if "show ui" is turned on
-		return;
-	}
+    parent_view->removeChild(gSnapshotFloaterView);
+    // make sure preview is below snapshot floater
+    parent_view->addChild(previewp);
+    parent_view->addChild(gSnapshotFloaterView);
 
-	LLFloater::draw();
+    //move snapshot floater to special purpose snapshotfloaterview
+    gFloaterView->removeChild(this);
+    gSnapshotFloaterView->addChild(this);
 
-	if (previewp && !isMinimized() && mThumbnailPlaceholder->getVisible())
-	{		
-		if(previewp->getThumbnailImage())
-		{
-			bool working = impl->getStatus() == ImplBase::STATUS_WORKING;
-			const LLRect& thumbnail_rect = getThumbnailPlaceholderRect();
-			const S32 thumbnail_w = previewp->getThumbnailWidth();
-			const S32 thumbnail_h = previewp->getThumbnailHeight();
+    // Pre-select "Current Window" resolution.
+    getChild<LLComboBox>("profile_size_combo")->selectNthItem(0);
+    getChild<LLComboBox>("postcard_size_combo")->selectNthItem(0);
+    getChild<LLComboBox>("texture_size_combo")->selectNthItem(0);
+    getChild<LLComboBox>("local_size_combo")->selectNthItem(8);
+    getChild<LLComboBox>("local_format_combo")->selectNthItem(0);
+
+    impl->mPreviewHandle = previewp->getHandle();
+    previewp->setContainer(this);
+    impl->updateControls(this);
+    impl->setAdvanced(gSavedSettings.getBOOL("AdvanceSnapshot"));
+    impl->updateLayout(this);
 
-			// calc preview offset within the preview rect
-			const S32 local_offset_x = (thumbnail_rect.getWidth() - thumbnail_w) / 2 ;
-			const S32 local_offset_y = (thumbnail_rect.getHeight() - thumbnail_h) / 2 ; // preview y pos within the preview rect
 
-			// calc preview offset within the floater rect
-			S32 offset_x = thumbnail_rect.mLeft + local_offset_x;
-			S32 offset_y = thumbnail_rect.mBottom + local_offset_y;
+    previewp->setThumbnailPlaceholderRect(getThumbnailPlaceholderRect());
+
+    return TRUE;
+}
 
-			gGL.matrixMode(LLRender::MM_MODELVIEW);
-			// Apply floater transparency to the texture unless the floater is focused.
-			F32 alpha = getTransparencyType() == TT_ACTIVE ? 1.0f : getCurrentTransparency();
-			LLColor4 color = working ? LLColor4::grey4 : LLColor4::white;
-			gl_draw_scaled_image(offset_x, offset_y, 
-					thumbnail_w, thumbnail_h,
-					previewp->getThumbnailImage(), color % alpha);
+// virtual
+void LLFloaterSnapshotBase::draw()
+{
+    LLSnapshotLivePreview* previewp = getPreviewView();
 
-			previewp->drawPreviewRect(offset_x, offset_y) ;
+    if (previewp && (previewp->isSnapshotActive() || previewp->getThumbnailLock()))
+    {
+        // don't render snapshot window in snapshot, even if "show ui" is turned on
+        return;
+    }
 
-			gGL.pushUIMatrix();
-			LLUI::translate((F32) thumbnail_rect.mLeft, (F32) thumbnail_rect.mBottom);
-			mThumbnailPlaceholder->draw();
-			gGL.popUIMatrix();
-		}
-	}
-	impl->updateLayout(this);
+    LLFloater::draw();
+
+    if (previewp && !isMinimized() && mThumbnailPlaceholder->getVisible())
+    {
+        if(previewp->getThumbnailImage())
+        {
+            bool working = impl->getStatus() == ImplBase::STATUS_WORKING;
+            const LLRect& thumbnail_rect = getThumbnailPlaceholderRect();
+            const S32 thumbnail_w = previewp->getThumbnailWidth();
+            const S32 thumbnail_h = previewp->getThumbnailHeight();
+
+            // calc preview offset within the preview rect
+            const S32 local_offset_x = (thumbnail_rect.getWidth() - thumbnail_w) / 2 ;
+            const S32 local_offset_y = (thumbnail_rect.getHeight() - thumbnail_h) / 2 ; // preview y pos within the preview rect
+
+            // calc preview offset within the floater rect
+            S32 offset_x = thumbnail_rect.mLeft + local_offset_x;
+            S32 offset_y = thumbnail_rect.mBottom + local_offset_y;
+
+            gGL.matrixMode(LLRender::MM_MODELVIEW);
+            // Apply floater transparency to the texture unless the floater is focused.
+            F32 alpha = getTransparencyType() == TT_ACTIVE ? 1.0f : getCurrentTransparency();
+            LLColor4 color = working ? LLColor4::grey4 : LLColor4::white;
+            gl_draw_scaled_image(offset_x, offset_y,
+                    thumbnail_w, thumbnail_h,
+                    previewp->getThumbnailImage(), color % alpha);
+
+            previewp->drawPreviewRect(offset_x, offset_y) ;
+
+            gGL.pushUIMatrix();
+            LLUI::translate((F32) thumbnail_rect.mLeft, (F32) thumbnail_rect.mBottom);
+            mThumbnailPlaceholder->draw();
+            gGL.popUIMatrix();
+        }
+    }
+    impl->updateLayout(this);
 }
 
 //virtual
 void LLFloaterSnapshot::onOpen(const LLSD& key)
 {
-	LLSnapshotLivePreview* preview = getPreviewView();
-	if(preview)
-	{
-		LL_DEBUGS() << "opened, updating snapshot" << LL_ENDL;
-		preview->setAllowFullScreenPreview(TRUE);
-		preview->updateSnapshot(TRUE);
-	}
-	focusFirstItem(FALSE);
-	gSnapshotFloaterView->setEnabled(TRUE);
-	gSnapshotFloaterView->setVisible(TRUE);
-	gSnapshotFloaterView->adjustToFitScreen(this, FALSE);
+    LLSnapshotLivePreview* preview = getPreviewView();
+    if(preview)
+    {
+        LL_DEBUGS() << "opened, updating snapshot" << LL_ENDL;
+        preview->setAllowFullScreenPreview(TRUE);
+        preview->updateSnapshot(TRUE);
+    }
+    focusFirstItem(FALSE);
+    gSnapshotFloaterView->setEnabled(TRUE);
+    gSnapshotFloaterView->setVisible(TRUE);
+    gSnapshotFloaterView->adjustToFitScreen(this, FALSE);
 
-	impl->updateControls(this);
-	impl->setAdvanced(gSavedSettings.getBOOL("AdvanceSnapshot"));
-	impl->updateLayout(this);
+    impl->updateControls(this);
+    impl->setAdvanced(gSavedSettings.getBOOL("AdvanceSnapshot"));
+    impl->updateLayout(this);
 
-	// Initialize default tab.
-	getChild<LLSideTrayPanelContainer>("panel_container")->getCurrentPanel()->onOpen(LLSD());
+    // Initialize default tab.
+    getChild<LLSideTrayPanelContainer>("panel_container")->getCurrentPanel()->onOpen(LLSD());
 }
 
 void LLFloaterSnapshot::onExtendFloater()
 {
-	impl->setAdvanced(gSavedSettings.getBOOL("AdvanceSnapshot"));
+    impl->setAdvanced(gSavedSettings.getBOOL("AdvanceSnapshot"));
 }
 
 void LLFloaterSnapshot::on360Snapshot()
@@ -1153,211 +1153,211 @@ void LLFloaterSnapshot::on360Snapshot()
 //virtual
 void LLFloaterSnapshotBase::onClose(bool app_quitting)
 {
-	getParent()->setMouseOpaque(FALSE);
+    getParent()->setMouseOpaque(FALSE);
 
-	//unfreeze everything, hide fullscreen preview
-	LLSnapshotLivePreview* previewp = getPreviewView();
-	if (previewp)
-	{
-		previewp->setAllowFullScreenPreview(FALSE);
-		previewp->setVisible(FALSE);
-		previewp->setEnabled(FALSE);
-	}
+    //unfreeze everything, hide fullscreen preview
+    LLSnapshotLivePreview* previewp = getPreviewView();
+    if (previewp)
+    {
+        previewp->setAllowFullScreenPreview(FALSE);
+        previewp->setVisible(FALSE);
+        previewp->setEnabled(FALSE);
+    }
 
-	gSavedSettings.setBOOL("FreezeTime", FALSE);
-	impl->mAvatarPauseHandles.clear();
+    gSavedSettings.setBOOL("FreezeTime", FALSE);
+    impl->mAvatarPauseHandles.clear();
 
-	if (impl->mLastToolset)
-	{
-		LLToolMgr::getInstance()->setCurrentToolset(impl->mLastToolset);
-	}
+    if (impl->mLastToolset)
+    {
+        LLToolMgr::getInstance()->setCurrentToolset(impl->mLastToolset);
+    }
 }
 
 // virtual
 S32 LLFloaterSnapshotBase::notify(const LLSD& info)
 {
-	if (info.has("set-ready"))
-	{
-		impl->setStatus(ImplBase::STATUS_READY);
-		return 1;
-	}
-
-	if (info.has("set-working"))
-	{
-		impl->setStatus(ImplBase::STATUS_WORKING);
-		return 1;
-	}
-
-	if (info.has("set-finished"))
-	{
-		LLSD data = info["set-finished"];
-		impl->setStatus(ImplBase::STATUS_FINISHED, data["ok"].asBoolean(), data["msg"].asString());
-		return 1;
-	}
-
-	if (info.has("snapshot-updating"))
-	{
-		// Disable the send/post/save buttons until snapshot is ready.
-		impl->updateControls(this);
-		return 1;
-	}
-
-	if (info.has("snapshot-updated"))
-	{
-		// Enable the send/post/save buttons.
-		impl->updateControls(this);
-		// We've just done refresh.
-		impl->setNeedRefresh(false);
-
-		// The refresh button is initially hidden. We show it after the first update,
-		// i.e. when preview appears.
-		if (mRefreshBtn && !mRefreshBtn->getVisible())
-		{
-			mRefreshBtn->setVisible(true);
-		}
-		return 1;
-	}
-
-	return 0;
+    if (info.has("set-ready"))
+    {
+        impl->setStatus(ImplBase::STATUS_READY);
+        return 1;
+    }
+
+    if (info.has("set-working"))
+    {
+        impl->setStatus(ImplBase::STATUS_WORKING);
+        return 1;
+    }
+
+    if (info.has("set-finished"))
+    {
+        LLSD data = info["set-finished"];
+        impl->setStatus(ImplBase::STATUS_FINISHED, data["ok"].asBoolean(), data["msg"].asString());
+        return 1;
+    }
+
+    if (info.has("snapshot-updating"))
+    {
+        // Disable the send/post/save buttons until snapshot is ready.
+        impl->updateControls(this);
+        return 1;
+    }
+
+    if (info.has("snapshot-updated"))
+    {
+        // Enable the send/post/save buttons.
+        impl->updateControls(this);
+        // We've just done refresh.
+        impl->setNeedRefresh(false);
+
+        // The refresh button is initially hidden. We show it after the first update,
+        // i.e. when preview appears.
+        if (mRefreshBtn && !mRefreshBtn->getVisible())
+        {
+            mRefreshBtn->setVisible(true);
+        }
+        return 1;
+    }
+
+    return 0;
 }
 
 // virtual
 S32 LLFloaterSnapshot::notify(const LLSD& info)
 {
-	bool res = LLFloaterSnapshotBase::notify(info);
-	if (res)
-		return res;
-	// A child panel wants to change snapshot resolution.
-	if (info.has("combo-res-change"))
-	{
-		std::string combo_name = info["combo-res-change"]["control-name"].asString();
-		((Impl*)impl)->updateResolution(getChild<LLUICtrl>(combo_name), this);
-		return 1;
-	}
-
-	if (info.has("custom-res-change"))
-	{
-		LLSD res = info["custom-res-change"];
-		((Impl*)impl)->applyCustomResolution(this, res["w"].asInteger(), res["h"].asInteger());
-		return 1;
-	}
-
-	if (info.has("keep-aspect-change"))
-	{
-		((Impl*)impl)->applyKeepAspectCheck(this, info["keep-aspect-change"].asBoolean());
-		return 1;
-	}
-
-	if (info.has("image-quality-change"))
-	{
-		((Impl*)impl)->onImageQualityChange(this, info["image-quality-change"].asInteger());
-		return 1;
-	}
-
-	if (info.has("image-format-change"))
-	{
-		((Impl*)impl)->onImageFormatChange(this);
-		return 1;
-	}
-    
-	return 0;
+    bool res = LLFloaterSnapshotBase::notify(info);
+    if (res)
+        return res;
+    // A child panel wants to change snapshot resolution.
+    if (info.has("combo-res-change"))
+    {
+        std::string combo_name = info["combo-res-change"]["control-name"].asString();
+        ((Impl*)impl)->updateResolution(getChild<LLUICtrl>(combo_name), this);
+        return 1;
+    }
+
+    if (info.has("custom-res-change"))
+    {
+        LLSD res = info["custom-res-change"];
+        ((Impl*)impl)->applyCustomResolution(this, res["w"].asInteger(), res["h"].asInteger());
+        return 1;
+    }
+
+    if (info.has("keep-aspect-change"))
+    {
+        ((Impl*)impl)->applyKeepAspectCheck(this, info["keep-aspect-change"].asBoolean());
+        return 1;
+    }
+
+    if (info.has("image-quality-change"))
+    {
+        ((Impl*)impl)->onImageQualityChange(this, info["image-quality-change"].asInteger());
+        return 1;
+    }
+
+    if (info.has("image-format-change"))
+    {
+        ((Impl*)impl)->onImageFormatChange(this);
+        return 1;
+    }
+
+    return 0;
 }
 
 BOOL LLFloaterSnapshot::isWaitingState()
 {
-	return (impl->getStatus() == ImplBase::STATUS_WORKING);
+    return (impl->getStatus() == ImplBase::STATUS_WORKING);
 }
 
 BOOL LLFloaterSnapshotBase::ImplBase::updatePreviewList(bool initialized)
 {
-	if (!initialized)
-		return FALSE;
+    if (!initialized)
+        return FALSE;
 
-	BOOL changed = FALSE;
-	LL_DEBUGS() << "npreviews: " << LLSnapshotLivePreview::sList.size() << LL_ENDL;
-	for (std::set<LLSnapshotLivePreview*>::iterator iter = LLSnapshotLivePreview::sList.begin();
-		iter != LLSnapshotLivePreview::sList.end(); ++iter)
-	{
-		changed |= LLSnapshotLivePreview::onIdle(*iter);
-	}
-	return changed;
+    BOOL changed = FALSE;
+    LL_DEBUGS() << "npreviews: " << LLSnapshotLivePreview::sList.size() << LL_ENDL;
+    for (std::set<LLSnapshotLivePreview*>::iterator iter = LLSnapshotLivePreview::sList.begin();
+        iter != LLSnapshotLivePreview::sList.end(); ++iter)
+    {
+        changed |= LLSnapshotLivePreview::onIdle(*iter);
+    }
+    return changed;
 }
 
 
 void LLFloaterSnapshotBase::ImplBase::updateLivePreview()
 {
-	if (ImplBase::updatePreviewList(true) && mFloater)
-	{
-		LL_DEBUGS() << "changed" << LL_ENDL;
-		updateControls(mFloater);
-	}
+    if (ImplBase::updatePreviewList(true) && mFloater)
+    {
+        LL_DEBUGS() << "changed" << LL_ENDL;
+        updateControls(mFloater);
+    }
 }
 
-//static 
+//static
 void LLFloaterSnapshot::update()
 {
-	LLFloaterSnapshot* inst = findInstance();
-	if (inst != NULL)
-	{
-		inst->impl->updateLivePreview();
-	}
-	else
-	{
-		ImplBase::updatePreviewList(false);
-	}
+    LLFloaterSnapshot* inst = findInstance();
+    if (inst != NULL)
+    {
+        inst->impl->updateLivePreview();
+    }
+    else
+    {
+        ImplBase::updatePreviewList(false);
+    }
 }
 
 // static
 LLFloaterSnapshot* LLFloaterSnapshot::findInstance()
 {
-	return LLFloaterReg::findTypedInstance<LLFloaterSnapshot>("snapshot");
+    return LLFloaterReg::findTypedInstance<LLFloaterSnapshot>("snapshot");
 }
 
 // static
 LLFloaterSnapshot* LLFloaterSnapshot::getInstance()
 {
-	return LLFloaterReg::getTypedInstance<LLFloaterSnapshot>("snapshot");
+    return LLFloaterReg::getTypedInstance<LLFloaterSnapshot>("snapshot");
 }
 
 // virtual
 void LLFloaterSnapshot::saveTexture()
 {
-	LL_DEBUGS() << "saveTexture" << LL_ENDL;
+    LL_DEBUGS() << "saveTexture" << LL_ENDL;
 
-	LLSnapshotLivePreview* previewp = getPreviewView();
-	if (!previewp)
-	{
-		llassert(previewp != NULL);
-		return;
-	}
+    LLSnapshotLivePreview* previewp = getPreviewView();
+    if (!previewp)
+    {
+        llassert(previewp != NULL);
+        return;
+    }
 
-	previewp->saveTexture();
+    previewp->saveTexture();
 }
 
 void LLFloaterSnapshot::saveLocal(const snapshot_saved_signal_t::slot_type& success_cb, const snapshot_saved_signal_t::slot_type& failure_cb)
 {
-	LL_DEBUGS() << "saveLocal" << LL_ENDL;
-	LLSnapshotLivePreview* previewp = getPreviewView();
-	llassert(previewp != NULL);
-	if (previewp)
-	{
-		previewp->saveLocal(success_cb, failure_cb);
-	}
+    LL_DEBUGS() << "saveLocal" << LL_ENDL;
+    LLSnapshotLivePreview* previewp = getPreviewView();
+    llassert(previewp != NULL);
+    if (previewp)
+    {
+        previewp->saveLocal(success_cb, failure_cb);
+    }
 }
 
 void LLFloaterSnapshotBase::postSave()
 {
-	impl->updateControls(this);
-	impl->setStatus(ImplBase::STATUS_WORKING);
+    impl->updateControls(this);
+    impl->setStatus(ImplBase::STATUS_WORKING);
 }
 
 // virtual
 void LLFloaterSnapshotBase::postPanelSwitch()
 {
-	impl->updateControls(this);
+    impl->updateControls(this);
 
-	// Remove the success/failure indicator whenever user presses a snapshot option button.
-	impl->setStatus(ImplBase::STATUS_READY);
+    // Remove the success/failure indicator whenever user presses a snapshot option button.
+    impl->setStatus(ImplBase::STATUS_READY);
 }
 
 void LLFloaterSnapshotBase::inventorySaveFailed()
@@ -1368,47 +1368,47 @@ void LLFloaterSnapshotBase::inventorySaveFailed()
 
 LLPointer<LLImageFormatted> LLFloaterSnapshotBase::getImageData()
 {
-	// FIXME: May not work for textures.
+    // FIXME: May not work for textures.
 
-	LLSnapshotLivePreview* previewp = getPreviewView();
-	if (!previewp)
-	{
-		llassert(previewp != NULL);
-		return NULL;
-	}
+    LLSnapshotLivePreview* previewp = getPreviewView();
+    if (!previewp)
+    {
+        llassert(previewp != NULL);
+        return NULL;
+    }
 
-	LLPointer<LLImageFormatted> img = previewp->getFormattedImage();
-	if (!img.get())
-	{
-		LL_WARNS() << "Empty snapshot image data" << LL_ENDL;
-		llassert(img.get() != NULL);
-	}
+    LLPointer<LLImageFormatted> img = previewp->getFormattedImage();
+    if (!img.get())
+    {
+        LL_WARNS() << "Empty snapshot image data" << LL_ENDL;
+        llassert(img.get() != NULL);
+    }
 
-	return img;
+    return img;
 }
 
 const LLVector3d& LLFloaterSnapshotBase::getPosTakenGlobal()
 {
-	LLSnapshotLivePreview* previewp = getPreviewView();
-	if (!previewp)
-	{
-		llassert(previewp != NULL);
-		return LLVector3d::zero;
-	}
+    LLSnapshotLivePreview* previewp = getPreviewView();
+    if (!previewp)
+    {
+        llassert(previewp != NULL);
+        return LLVector3d::zero;
+    }
 
-	return previewp->getPosTakenGlobal();
+    return previewp->getPosTakenGlobal();
 }
 
 // static
 void LLFloaterSnapshot::setAgentEmail(const std::string& email)
 {
-	LLFloaterSnapshot* instance = findInstance();
-	if (instance)
-	{
-		LLSideTrayPanelContainer* panel_container = instance->getChild<LLSideTrayPanelContainer>("panel_container");
-		LLPanel* postcard_panel = panel_container->getPanelByName("panel_snapshot_postcard");
-		postcard_panel->notify(LLSD().with("agent-email", email));
-	}
+    LLFloaterSnapshot* instance = findInstance();
+    if (instance)
+    {
+        LLSideTrayPanelContainer* panel_container = instance->getChild<LLSideTrayPanelContainer>("panel_container");
+        LLPanel* postcard_panel = panel_container->getPanelByName("panel_snapshot_postcard");
+        postcard_panel->notify(LLSD().with("agent-email", email));
+    }
 }
 
 ///----------------------------------------------------------------------------
@@ -1426,69 +1426,69 @@ LLSnapshotFloaterView::~LLSnapshotFloaterView()
 // virtual
 BOOL LLSnapshotFloaterView::handleKey(KEY key, MASK mask, BOOL called_from_parent)
 {
-	// use default handler when not in freeze-frame mode
-	if(!gSavedSettings.getBOOL("FreezeTime"))
-	{
-		return LLFloaterView::handleKey(key, mask, called_from_parent);
-	}
-
-	if (called_from_parent)
-	{
-		// pass all keystrokes down
-		LLFloaterView::handleKey(key, mask, called_from_parent);
-	}
-	else
-	{
-		// bounce keystrokes back down
-		LLFloaterView::handleKey(key, mask, TRUE);
-	}
-	return TRUE;
+    // use default handler when not in freeze-frame mode
+    if(!gSavedSettings.getBOOL("FreezeTime"))
+    {
+        return LLFloaterView::handleKey(key, mask, called_from_parent);
+    }
+
+    if (called_from_parent)
+    {
+        // pass all keystrokes down
+        LLFloaterView::handleKey(key, mask, called_from_parent);
+    }
+    else
+    {
+        // bounce keystrokes back down
+        LLFloaterView::handleKey(key, mask, TRUE);
+    }
+    return TRUE;
 }
 
 // virtual
 BOOL LLSnapshotFloaterView::handleMouseDown(S32 x, S32 y, MASK mask)
 {
-	// use default handler when not in freeze-frame mode
-	if(!gSavedSettings.getBOOL("FreezeTime"))
-	{
-		return LLFloaterView::handleMouseDown(x, y, mask);
-	}
-	// give floater a change to handle mouse, else camera tool
-	if (childrenHandleMouseDown(x, y, mask) == NULL)
-	{
-		LLToolMgr::getInstance()->getCurrentTool()->handleMouseDown( x, y, mask );
-	}
-	return TRUE;
+    // use default handler when not in freeze-frame mode
+    if(!gSavedSettings.getBOOL("FreezeTime"))
+    {
+        return LLFloaterView::handleMouseDown(x, y, mask);
+    }
+    // give floater a change to handle mouse, else camera tool
+    if (childrenHandleMouseDown(x, y, mask) == NULL)
+    {
+        LLToolMgr::getInstance()->getCurrentTool()->handleMouseDown( x, y, mask );
+    }
+    return TRUE;
 }
 
 // virtual
 BOOL LLSnapshotFloaterView::handleMouseUp(S32 x, S32 y, MASK mask)
 {
-	// use default handler when not in freeze-frame mode
-	if(!gSavedSettings.getBOOL("FreezeTime"))
-	{
-		return LLFloaterView::handleMouseUp(x, y, mask);
-	}
-	// give floater a change to handle mouse, else camera tool
-	if (childrenHandleMouseUp(x, y, mask) == NULL)
-	{
-		LLToolMgr::getInstance()->getCurrentTool()->handleMouseUp( x, y, mask );
-	}
-	return TRUE;
+    // use default handler when not in freeze-frame mode
+    if(!gSavedSettings.getBOOL("FreezeTime"))
+    {
+        return LLFloaterView::handleMouseUp(x, y, mask);
+    }
+    // give floater a change to handle mouse, else camera tool
+    if (childrenHandleMouseUp(x, y, mask) == NULL)
+    {
+        LLToolMgr::getInstance()->getCurrentTool()->handleMouseUp( x, y, mask );
+    }
+    return TRUE;
 }
 
 // virtual
 BOOL LLSnapshotFloaterView::handleHover(S32 x, S32 y, MASK mask)
 {
-	// use default handler when not in freeze-frame mode
-	if(!gSavedSettings.getBOOL("FreezeTime"))
-	{
-		return LLFloaterView::handleHover(x, y, mask);
-	}	
-	// give floater a change to handle mouse, else camera tool
-	if (childrenHandleHover(x, y, mask) == NULL)
-	{
-		LLToolMgr::getInstance()->getCurrentTool()->handleHover( x, y, mask );
-	}
-	return TRUE;
+    // use default handler when not in freeze-frame mode
+    if(!gSavedSettings.getBOOL("FreezeTime"))
+    {
+        return LLFloaterView::handleHover(x, y, mask);
+    }
+    // give floater a change to handle mouse, else camera tool
+    if (childrenHandleHover(x, y, mask) == NULL)
+    {
+        LLToolMgr::getInstance()->getCurrentTool()->handleHover( x, y, mask );
+    }
+    return TRUE;
 }