Second Life viewer sources 1.13.2.12

1 files changed, 969 insertions, 0 deletions

diff --git a/linden/indra/newview/llfloatertools.cpp b/linden/indra/newview/llfloatertools.cpp
new file mode 100644
index 0000000..c9edf98
--- /dev/null
+++ b/linden/indra/newview/llfloatertools.cpp
@@ -0,0 +1,969 @@
+/** 
+ * @file llfloatertools.cpp
+ * @brief The edit tools, including move, position, land, etc.
+ *
+ * Copyright (c) 2002-2007, Linden Research, Inc.
+ * 
+ * The source code in this file ("Source Code") is provided by Linden Lab
+ * to you under the terms of the GNU General Public License, version 2.0
+ * ("GPL"), unless you have obtained a separate licensing agreement
+ * ("Other License"), formally executed by you and Linden Lab.  Terms of
+ * the GPL can be found in doc/GPL-license.txt in this distribution, or
+ * online at http://secondlife.com/developers/opensource/gplv2
+ * 
+ * There are special exceptions to the terms and conditions of the GPL as
+ * it is applied to this Source Code. View the full text of the exception
+ * in the file doc/FLOSS-exception.txt in this software distribution, or
+ * online at http://secondlife.com/developers/opensource/flossexception
+ * 
+ * By copying, modifying or distributing this software, you acknowledge
+ * that you have read and understood your obligations described above,
+ * and agree to abide by those obligations.
+ * 
+ * ALL LINDEN LAB SOURCE CODE IS PROVIDED "AS IS." LINDEN LAB MAKES NO
+ * WARRANTIES, EXPRESS, IMPLIED OR OTHERWISE, REGARDING ITS ACCURACY,
+ * COMPLETENESS OR PERFORMANCE.
+ */
+
+#include "llviewerprecompiledheaders.h"
+
+#include "llfloatertools.h"
+
+#include "llfontgl.h"
+#include "llcoord.h"
+#include "llgl.h"
+
+#include "llagent.h"
+#include "llbutton.h"
+#include "llcheckboxctrl.h"
+#include "llcombobox.h"
+#include "lldraghandle.h"
+#include "llfloaterbuildoptions.h"
+#include "llfloateropenobject.h"
+#include "llfocusmgr.h"
+#include "llmenugl.h"
+#include "llpanelcontents.h"
+#include "llpanelface.h"
+#include "llpanelland.h"
+#include "llpanelinventory.h"
+#include "llpanelobject.h"
+#include "llpanelvolume.h"
+#include "llpanelpermissions.h"
+#include "llselectmgr.h"
+#include "llstatusbar.h"
+#include "lltabcontainer.h"
+#include "lltextbox.h"
+#include "lltoolbrush.h"
+#include "lltoolcomp.h"
+#include "lltooldraganddrop.h"
+#include "lltoolface.h"
+#include "lltoolfocus.h"
+#include "lltoolgrab.h"
+#include "lltoolgrab.h"
+#include "lltoolindividual.h"
+#include "lltoolmgr.h"
+#include "lltoolpie.h"
+#include "lltoolpipette.h"
+#include "lltoolplacer.h"
+#include "lltoolselect.h"
+#include "lltoolselectland.h"
+#include "llui.h"
+#include "llviewermenu.h"
+#include "llviewerparcelmgr.h"
+#include "llviewerwindow.h"
+#include "llviewercontrol.h"
+#include "llvolumesliderctrl.h"
+#include "viewer.h"
+
+#include "llvieweruictrlfactory.h"
+
+// Globals
+LLFloaterTools *gFloaterTools = NULL;
+
+
+const LLString PANEL_NAMES[LLFloaterTools::PANEL_COUNT] =
+{
+        LLString("General"),    // PANEL_GENERAL,
+        LLString("Object"),     // PANEL_OBJECT,
+        LLString("Features"),   // PANEL_FEATURES,
+        LLString("Texture"),    // PANEL_FACE,
+        LLString("Content"),    // PANEL_CONTENTS,
+};
+
+// Local prototypes
+void commit_select_tool(LLUICtrl *ctrl, void *data);
+void commit_select_component(LLUICtrl *ctrl, void *data);
+void click_show_more(void*);
+void click_popup_info(void*);
+void click_popup_done(void*);
+void click_popup_minimize(void*);
+void click_popup_grab_drag(LLUICtrl *, void*);
+void click_popup_grab_lift(LLUICtrl *, void*);
+void click_popup_grab_spin(LLUICtrl *, void*);
+void click_popup_rotate_left(void*);
+void click_popup_rotate_reset(void*);
+void click_popup_rotate_right(void*);
+void click_popup_dozer_mode(LLUICtrl *, void *user);
+void click_popup_dozer_size(LLUICtrl *, void *user);
+void click_dozer_size(LLUICtrl *, void*);
+void click_apply_to_selection(void*);
+void commit_radio_zoom(LLUICtrl *, void*);
+void commit_radio_orbit(LLUICtrl *, void*);
+void commit_radio_pan(LLUICtrl *, void*);
+void commit_grid_mode(LLUICtrl *, void*);
+void commit_slider_zoom(LLUICtrl *, void*);
+
+
+//static
+void*   LLFloaterTools::createPanelPermissions(void* data)
+{
+        LLFloaterTools* floater = (LLFloaterTools*)data;
+        floater->mPanelPermissions = new LLPanelPermissions("General");
+        return floater->mPanelPermissions;
+}
+//static
+void*   LLFloaterTools::createPanelObject(void* data)
+{
+        LLFloaterTools* floater = (LLFloaterTools*)data;
+        floater->mPanelObject = new LLPanelObject("Object");
+        return floater->mPanelObject;
+}
+
+//static
+void*   LLFloaterTools::createPanelVolume(void* data)
+{
+        LLFloaterTools* floater = (LLFloaterTools*)data;
+        floater->mPanelVolume = new LLPanelVolume("Features");
+        return floater->mPanelVolume;
+}
+
+//static
+void*   LLFloaterTools::createPanelFace(void* data)
+{
+        LLFloaterTools* floater = (LLFloaterTools*)data;
+        floater->mPanelFace = new LLPanelFace("Texture");
+        return floater->mPanelFace;
+}
+
+//static
+void*   LLFloaterTools::createPanelContents(void* data)
+{
+        LLFloaterTools* floater = (LLFloaterTools*)data;
+        floater->mPanelContents = new LLPanelContents("Contents");
+        return floater->mPanelContents;
+}
+
+//static
+void*   LLFloaterTools::createPanelContentsInventory(void* data)
+{
+        LLFloaterTools* floater = (LLFloaterTools*)data;
+        floater->mPanelContents->mPanelInventory = new LLPanelInventory("ContentsInventory", LLRect());
+        return floater->mPanelContents->mPanelInventory;
+}
+
+//static
+void*   LLFloaterTools::createPanelLandInfo(void* data)
+{
+        LLFloaterTools* floater = (LLFloaterTools*)data;
+        floater->mPanelLandInfo = new LLPanelLandInfo("land info panel");
+        return floater->mPanelLandInfo;
+}
+
+BOOL    LLFloaterTools::postBuild()
+{
+        
+        // Hide until tool selected
+        setVisible(FALSE);
+
+        // Since we constantly show and hide this during drags, don't
+        // make sounds on visibility changes.
+        setSoundFlags(LLView::SILENT);
+
+        mDragHandle->setEnabled( !gSavedSettings.getBOOL("ToolboxAutoMove") );
+
+        LLRect rect;
+        mBtnFocus = LLUICtrlFactory::getButtonByName(this,"button focus");//btn;
+        childSetAction("button focus",LLFloaterTools::setEditTool, (void*)gToolCamera);
+        mBtnMove = LLUICtrlFactory::getButtonByName(this,"button move");
+        childSetAction("button move",LLFloaterTools::setEditTool, (void*)gToolGrab);
+        mBtnEdit = LLUICtrlFactory::getButtonByName(this,"button edit");
+        childSetAction("button edit",LLFloaterTools::setEditTool, (void*)gToolTranslate);
+        mBtnCreate = LLUICtrlFactory::getButtonByName(this,"button create");
+        childSetAction("button create",LLFloaterTools::setEditTool, (void*)gToolCreate);
+        mBtnLand = LLUICtrlFactory::getButtonByName(this, "button land" );
+        childSetAction("button land",LLFloaterTools::setEditTool, (void*)gToolParcel);
+        mTextStatus = LLUICtrlFactory::getTextBoxByName(this,"text status");
+        mRadioZoom = LLUICtrlFactory::getCheckBoxByName(this,"radio zoom");
+        mSliderZoom = LLViewerUICtrlFactory::getVolumeSliderByName(this,"slider zoom");
+        childSetCommitCallback("slider zoom",commit_slider_zoom,this);
+        mRadioOrbit = LLUICtrlFactory::getCheckBoxByName(this,"radio orbit");
+        childSetCommitCallback("radio orbit",commit_radio_orbit,this);
+        mRadioPan = LLUICtrlFactory::getCheckBoxByName(this,"radio pan");
+        childSetCommitCallback("radio pan",commit_radio_pan,this);
+        mRadioMove = LLUICtrlFactory::getCheckBoxByName(this,"radio move");
+        childSetCommitCallback("radio move",click_popup_grab_drag,this);
+        mRadioLift = LLUICtrlFactory::getCheckBoxByName(this,"radio lift");
+        childSetCommitCallback("radio lift",click_popup_grab_lift,this);
+        mRadioSpin = LLUICtrlFactory::getCheckBoxByName(this,"radio spin");
+        childSetCommitCallback("radio spin",click_popup_grab_spin,NULL);
+        mRadioPosition = LLUICtrlFactory::getCheckBoxByName(this,"radio position");
+        childSetCommitCallback("radio position",commit_select_tool,gToolTranslate);
+        mRadioRotate = LLUICtrlFactory::getCheckBoxByName(this,"radio rotate");
+        childSetCommitCallback("radio rotate",commit_select_tool,gToolRotate);
+        mRadioStretch = LLUICtrlFactory::getCheckBoxByName(this,"radio stretch");
+        childSetCommitCallback("radio stretch",commit_select_tool,gToolStretch);
+        mRadioSelectFace = LLUICtrlFactory::getCheckBoxByName(this,"radio select face");
+        childSetCommitCallback("radio select face",commit_select_tool,gToolFace);
+        mCheckSelectIndividual = LLUICtrlFactory::getCheckBoxByName(this,"checkbox edit linked parts");
+        childSetValue("checkbox edit linked parts",(BOOL)!gSavedSettings.getBOOL("SelectLinkedSet"));
+        childSetCommitCallback("checkbox edit linked parts",commit_select_component,this);
+        mCheckSnapToGrid = LLUICtrlFactory::getCheckBoxByName(this,"checkbox snap to grid");
+        childSetValue("checkbox snap to grid",(BOOL)gSavedSettings.getBOOL("SnapEnabled"));
+        mBtnGridOptions = LLUICtrlFactory::getButtonByName(this,"Options...");
+        childSetAction("Options...",onClickGridOptions, this);
+        mCheckStretchUniform = LLUICtrlFactory::getCheckBoxByName(this,"checkbox uniform");
+        childSetValue("checkbox uniform",(BOOL)gSavedSettings.getBOOL("ScaleUniform"));
+        mCheckStretchTexture = LLUICtrlFactory::getCheckBoxByName(this,"checkbox stretch textures");
+        childSetValue("checkbox stretch textures",(BOOL)gSavedSettings.getBOOL("ScaleStretchTextures"));
+        mTextGridMode = LLUICtrlFactory::getTextBoxByName(this,"text ruler mode");
+        mComboGridMode = LLUICtrlFactory::getComboBoxByName(this,"combobox grid mode");
+        childSetCommitCallback("combobox grid mode",commit_grid_mode, this);
+        //
+        // Create Buttons
+        //
+
+        static  const LLString  toolNames[]={
+                        "ToolCube",
+                        "ToolPrism",
+                        "ToolPyramid",
+                        "ToolTetrahedron",
+                        "ToolCylinder",
+                        "ToolHemiCylinder",
+                        "ToolCone",
+                        "ToolHemiCone",
+                        "ToolSphere",
+                        "ToolHemiSphere",
+                        "ToolTorus",
+                        "ToolTube",
+                        "ToolRing",
+                        "ToolTree",
+                        "ToolGrass"};
+        void*   toolData[]={
+                        &LLToolPlacerPanel::sCube,
+                        &LLToolPlacerPanel::sPrism,
+                        &LLToolPlacerPanel::sPyramid,
+                        &LLToolPlacerPanel::sTetrahedron,
+                        &LLToolPlacerPanel::sCylinder,
+                        &LLToolPlacerPanel::sCylinderHemi,
+                        &LLToolPlacerPanel::sCone,
+                        &LLToolPlacerPanel::sConeHemi,
+                        &LLToolPlacerPanel::sSphere,
+                        &LLToolPlacerPanel::sSphereHemi,
+                        &LLToolPlacerPanel::sTorus,
+                        &LLToolPlacerPanel::sSquareTorus,
+                        &LLToolPlacerPanel::sTriangleTorus,
+                        &LLToolPlacerPanel::sTree,
+                        &LLToolPlacerPanel::sGrass};
+        for(int t=0;t<sizeof(toolNames)/sizeof(toolNames[0]);t++)
+        {
+                LLButton *found = LLViewerUICtrlFactory::getButtonByName(this,toolNames[t]);
+                if(found)
+                {
+                        found->setClickedCallback(setObjectType,toolData[t]);
+                        mButtons.push_back( found );
+                }else{
+                        llwarns << "Tool button not found! DOA Pending." << llendl;
+                }
+        }
+        mCheckCopySelection = LLUICtrlFactory::getCheckBoxByName(this,"checkbox copy selection");
+        childSetValue("checkbox copy selection",(BOOL)gSavedSettings.getBOOL("CreateToolCopySelection"));
+        mCheckSticky = LLUICtrlFactory::getCheckBoxByName(this,"checkbox sticky");
+        childSetValue("checkbox sticky",(BOOL)gSavedSettings.getBOOL("CreateToolKeepSelected"));
+        mCheckCopyCenters = LLUICtrlFactory::getCheckBoxByName(this,"checkbox copy centers");
+        childSetValue("checkbox copy centers",(BOOL)gSavedSettings.getBOOL("CreateToolCopyCenters"));
+        mCheckCopyRotates = LLUICtrlFactory::getCheckBoxByName(this,"checkbox copy rotates");
+        childSetValue("checkbox copy rotates",(BOOL)gSavedSettings.getBOOL("CreateToolCopyRotates"));
+        mRadioSelectLand = LLUICtrlFactory::getCheckBoxByName(this,"radio select land");
+        childSetCommitCallback("radio select land",commit_select_tool, gToolParcel);
+        mRadioDozerFlatten = LLUICtrlFactory::getCheckBoxByName(this,"radio flatten");
+        childSetCommitCallback("radio flatten",click_popup_dozer_mode,  (void*)0);
+        mRadioDozerRaise = LLUICtrlFactory::getCheckBoxByName(this,"radio raise");
+        childSetCommitCallback("radio raise",click_popup_dozer_mode,  (void*)1);
+        mRadioDozerLower = LLUICtrlFactory::getCheckBoxByName(this,"radio lower");
+        childSetCommitCallback("radio lower",click_popup_dozer_mode,  (void*)2);
+        mRadioDozerSmooth = LLUICtrlFactory::getCheckBoxByName(this,"radio smooth");
+        childSetCommitCallback("radio smooth",click_popup_dozer_mode,  (void*)3);
+        mRadioDozerNoise = LLUICtrlFactory::getCheckBoxByName(this,"radio noise");
+        childSetCommitCallback("radio noise",click_popup_dozer_mode,  (void*)4);
+        mRadioDozerRevert = LLUICtrlFactory::getCheckBoxByName(this,"radio revert");
+        childSetCommitCallback("radio revert",click_popup_dozer_mode,  (void*)5);
+        mComboDozerSize = LLUICtrlFactory::getComboBoxByName(this,"combobox brush size");
+        childSetCommitCallback("combobox brush size",click_dozer_size,  (void*)0);
+        if(mComboDozerSize) mComboDozerSize->setCurrentByIndex(0);
+        mBtnApplyToSelection = LLUICtrlFactory::getButtonByName(this,"button apply to selection");
+        childSetAction("button apply to selection",click_apply_to_selection,  (void*)0);
+        mCheckShowOwners = LLUICtrlFactory::getCheckBoxByName(this,"checkbox show owners");
+        childSetValue("checkbox show owners",gSavedSettings.getBOOL("ShowParcelOwners"));
+        childSetAction("button more", click_show_more, this);
+        childSetAction("button less", click_show_more, this);
+        mTab = LLUICtrlFactory::getTabContainerByName(this,"Object Info Tabs");
+        if(mTab)
+        {
+                mTab->setVisible( gSavedSettings.getBOOL("ToolboxShowMore") );
+                mTab->setFollows(FOLLOWS_TOP | FOLLOWS_LEFT);
+                mTab->setVisible( gSavedSettings.getBOOL("ToolboxShowMore") );
+                mTab->setBorderVisible(FALSE);
+        }
+        mTab->selectFirstTab();
+        return TRUE;
+}
+
+// Create the popupview with a dummy center.  It will be moved into place
+// during LLViewerWindow's per-frame hover processing.
+LLFloaterTools::LLFloaterTools()
+:       LLFloater("toolbox floater"),
+        mBtnFocus(NULL),
+        mBtnMove(NULL),
+        mBtnEdit(NULL),
+        mBtnCreate(NULL),
+        mBtnLand(NULL),
+        mTextStatus(NULL),
+
+        mRadioOrbit(NULL),
+        mRadioZoom(NULL),
+        mRadioPan(NULL),
+
+        mRadioMove(NULL),
+        mRadioLift(NULL),
+        mRadioSpin(NULL),
+
+        mRadioPosition(NULL),
+        mRadioRotate(NULL),
+        mRadioStretch(NULL),
+        mRadioSelectFace(NULL),
+        mCheckSelectIndividual(NULL),
+
+        mCheckSnapToGrid(NULL),
+        mBtnGridOptions(NULL),
+        mTextGridMode(NULL),
+        mComboGridMode(NULL),
+        mCheckStretchUniform(NULL),
+        mCheckStretchTexture(NULL),
+
+        mBtnRotateLeft(NULL),
+        mBtnRotateReset(NULL),
+        mBtnRotateRight(NULL),
+
+        mBtnDelete(NULL),
+        mBtnDuplicate(NULL),
+        mBtnDuplicateInPlace(NULL),
+
+        mCheckSticky(NULL),
+        mCheckCopySelection(NULL),
+        mCheckCopyCenters(NULL),
+        mCheckCopyRotates(NULL),
+        mRadioSelectLand(NULL),
+        mRadioDozerFlatten(NULL),
+        mRadioDozerRaise(NULL),
+        mRadioDozerLower(NULL),
+        mRadioDozerSmooth(NULL),
+        mRadioDozerNoise(NULL),
+        mRadioDozerRevert(NULL),
+        mComboDozerSize(NULL),
+        mBtnApplyToSelection(NULL),
+        mCheckShowOwners(NULL),
+
+
+        mTab(NULL),
+        mPanelPermissions(NULL),
+        mPanelObject(NULL),
+        mPanelVolume(NULL),
+        mPanelContents(NULL),
+        mPanelFace(NULL),
+        mPanelLandInfo(NULL),
+
+        mTabLand(NULL),
+        mDirty(TRUE),
+        mLastTool(gToolNull)
+{
+        mAutoFocus = FALSE;
+        LLCallbackMap::map_t factory_map;
+        factory_map["General"] = LLCallbackMap(createPanelPermissions, this);//LLPanelPermissions
+        factory_map["Object"] = LLCallbackMap(createPanelObject, this);//LLPanelObject
+        factory_map["Features"] = LLCallbackMap(createPanelVolume, this);//LLPanelVolume
+        factory_map["Texture"] = LLCallbackMap(createPanelFace, this);//LLPanelFace
+        factory_map["Contents"] = LLCallbackMap(createPanelContents, this);//LLPanelContents
+        factory_map["ContentsInventory"] = LLCallbackMap(createPanelContentsInventory, this);//LLPanelContents
+        factory_map["land info panel"] = LLCallbackMap(createPanelLandInfo, this);//LLPanelLandInfo
+
+        gUICtrlFactory->buildFloater(this,"floater_tools.xml",&factory_map);
+
+        mLargeHeight = getRect().getHeight();
+        mSmallHeight = mLargeHeight;
+        if (mTab) mSmallHeight -= mTab->getRect().getHeight();
+        
+        gSavedSettings.setBOOL("ToolboxShowMore", TRUE); // force a toggle initially
+        showMore(FALSE);
+}
+
+LLFloaterTools::~LLFloaterTools()
+{
+        showMore(FALSE);
+        // children automatically deleted
+}
+
+void LLFloaterTools::setStatusText(const LLString& text)
+{
+        mTextStatus->setText(text);
+}
+
+void LLFloaterTools::refresh()
+{
+        const S32 INFO_WIDTH = mRect.getWidth();
+        const S32 INFO_HEIGHT = 384;
+        LLRect object_info_rect(0, 0, INFO_WIDTH, -INFO_HEIGHT);
+        BOOL all_volume = gSelectMgr->selectionAllPCode( LL_PCODE_VOLUME );
+
+        S32 idx_features = mTab->getPanelIndexByTitle(PANEL_NAMES[PANEL_FEATURES]);
+        S32 idx_face = mTab->getPanelIndexByTitle(PANEL_NAMES[PANEL_FACE]);
+        S32 idx_contents = mTab->getPanelIndexByTitle(PANEL_NAMES[PANEL_CONTENTS]);
+
+        S32 selected_index = mTab->getCurrentPanelIndex();
+
+        if (!all_volume && (selected_index == idx_features || selected_index == idx_face ||
+                selected_index == idx_contents))
+        {
+                mTab->selectFirstTab();
+        }
+
+        mTab->enableTabButton(idx_features, all_volume);
+        mTab->enableTabButton(idx_face, all_volume);
+        mTab->enableTabButton(idx_contents, all_volume);
+
+        mPanelPermissions->refresh();
+        mPanelObject->refresh();
+        mPanelVolume->refresh();
+        mPanelFace->refresh();
+        mPanelContents->refresh();
+        mPanelLandInfo->refresh();
+}
+
+void LLFloaterTools::draw()
+{
+        if (mDirty)
+        {
+                refresh();
+                mDirty = FALSE;
+        }
+
+        mCheckSelectIndividual->set(!gSavedSettings.getBOOL("SelectLinkedSet"));
+        LLFloater::draw();
+}
+
+void LLFloaterTools::dirty()
+{
+        mDirty = TRUE; 
+        LLFloaterOpenObject::dirty();
+}
+
+// Clean up any tool state that should not persist when the
+// floater is closed.
+void LLFloaterTools::resetToolState()
+{
+        gCameraBtnOrbit = FALSE;
+        gCameraBtnPan = FALSE;
+
+        gGrabBtnSpin = FALSE;
+        gGrabBtnVertical = FALSE;
+}
+
+void LLFloaterTools::updatePopup(LLCoordGL center, MASK mask)
+{
+        LLTool *tool = gToolMgr->getCurrentTool( mask );
+
+        // HACK to allow seeing the buttons when you have the app in a window.
+        // Keep the visibility the same as it 
+        if (tool == gToolNull)
+        {
+                return;
+        }
+        
+        // Focus buttons
+        BOOL focus_visible = (  tool == gToolCamera );
+
+        mBtnFocus       ->setToggleState( focus_visible );
+
+        mRadioZoom      ->setVisible( focus_visible );
+        mRadioOrbit     ->setVisible( focus_visible );
+        mRadioPan       ->setVisible( focus_visible );
+        mSliderZoom ->setVisible( focus_visible );
+
+        mRadioZoom      ->set(  !gCameraBtnOrbit &&
+                                                !gCameraBtnPan &&
+                                                !(mask == MASK_ORBIT) &&
+                                                !(mask == (MASK_ORBIT | MASK_ALT)) &&
+                                                !(mask == MASK_PAN) &&
+                                                !(mask == (MASK_PAN | MASK_ALT)) );
+
+        mRadioOrbit     ->set(  gCameraBtnOrbit || 
+                                                (mask == MASK_ORBIT) ||
+                                                (mask == (MASK_ORBIT | MASK_ALT)) );
+
+        mRadioPan       ->set(  gCameraBtnPan ||
+                                                (mask == MASK_PAN) ||
+                                                (mask == (MASK_PAN | MASK_ALT)) );
+
+        // multiply by correction factor because volume sliders go [0, 0.5]
+        mSliderZoom ->setValue( gAgent.getCameraZoomFraction() * 0.5f);
+
+        // Move buttons
+        BOOL move_visible = (tool == gToolGrab);
+
+        if (mBtnMove) mBtnMove  ->setToggleState( move_visible );
+
+        // HACK - highlight buttons for next click
+        if (mRadioMove)
+        {
+                mRadioMove      ->setVisible( move_visible );
+                mRadioMove      ->set(  !gGrabBtnSpin && 
+                                                        !gGrabBtnVertical &&
+                                                        !(mask == MASK_VERTICAL) && 
+                                                        !(mask == MASK_SPIN) );
+        }
+
+        if (mRadioLift)
+        {
+                mRadioLift      ->setVisible( move_visible );
+                mRadioLift      ->set(  gGrabBtnVertical || 
+                                                        (mask == MASK_VERTICAL) );
+        }
+
+        if (mRadioSpin)
+        {
+                mRadioSpin      ->setVisible( move_visible );
+                mRadioSpin      ->set(  gGrabBtnSpin || 
+                                                        (mask == MASK_SPIN) );
+        }
+
+        // Edit buttons
+        BOOL edit_visible = tool == gToolTranslate ||
+                                                tool == gToolRotate ||
+                                                tool == gToolStretch ||
+                                                tool == gToolFace ||
+                                                tool == gToolIndividual ||
+                                                tool == gToolPipette;
+
+        mBtnEdit        ->setToggleState( edit_visible );
+
+        mRadioPosition  ->setVisible( edit_visible );
+        mRadioRotate    ->setVisible( edit_visible );
+        mRadioStretch   ->setVisible( edit_visible );
+        if (mRadioSelectFace)
+        {
+                mRadioSelectFace->setVisible( edit_visible );
+                mRadioSelectFace->set( tool == gToolFace );
+        }
+
+        if (mCheckSelectIndividual)
+        {
+                mCheckSelectIndividual->setVisible(edit_visible);
+                mCheckSelectIndividual->set(!gSavedSettings.getBOOL("SelectLinkedSet"));
+        }
+
+        mRadioPosition  ->set( tool == gToolTranslate );
+        mRadioRotate    ->set( tool == gToolRotate );
+        mRadioStretch   ->set( tool == gToolStretch );
+
+        if (mComboGridMode) 
+        {
+                mComboGridMode          ->setVisible( edit_visible );
+                S32 index = mComboGridMode->getCurrentIndex();
+                mComboGridMode->removeall();
+
+                switch (gSelectMgr->getSelectType())
+                {
+                case SELECT_TYPE_HUD:
+                        mComboGridMode->add("Screen");
+                        mComboGridMode->add("Local");
+                        //mComboGridMode->add("Reference");
+                        break;
+                case SELECT_TYPE_WORLD:
+                        mComboGridMode->add("World");
+                        mComboGridMode->add("Local");
+                        mComboGridMode->add("Reference");
+                        break;
+                case SELECT_TYPE_ATTACHMENT:
+                        mComboGridMode->add("Attachment");
+                        mComboGridMode->add("Local");
+                        mComboGridMode->add("Reference");
+                        break;
+                }
+
+                mComboGridMode->setCurrentByIndex(index);
+        }
+        if (mTextGridMode) mTextGridMode->setVisible( edit_visible );
+
+        // Snap to grid disabled for grab tool - very confusing
+        if (mCheckSnapToGrid) mCheckSnapToGrid->setVisible( edit_visible /* || tool == gToolGrab */ );
+        if (mBtnGridOptions) mBtnGridOptions->setVisible( edit_visible /* || tool == gToolGrab */ );
+
+        //mCheckSelectLinked    ->setVisible( edit_visible );
+        if (mCheckStretchUniform) mCheckStretchUniform->setVisible( edit_visible );
+        if (mCheckStretchTexture) mCheckStretchTexture->setVisible( edit_visible );
+
+        // Create buttons
+        BOOL create_visible = (tool == gToolCreate);
+
+        mBtnCreate      ->setToggleState(       tool == gToolCreate );
+
+        if (mCheckCopySelection
+                && mCheckCopySelection->get())
+        {
+                // don't highlight any placer button
+                for (std::vector<LLButton*>::size_type i = 0; i < mButtons.size(); i++)
+                {
+                        mButtons[i]->setToggleState(FALSE);
+                        mButtons[i]->setVisible( create_visible );
+                }
+        }
+        else
+        {
+                // Highlight the correct placer button
+                for( std::vector<LLButton*>::size_type i = 0; i < mButtons.size(); i++ )
+                {
+                        LLPCode pcode = LLToolPlacer::getObjectType();
+                        void *userdata = mButtons[i]->getCallbackUserData();
+                        LLPCode *cur = (LLPCode*) userdata;
+
+                        BOOL state = (pcode == *cur);
+                        mButtons[i]->setToggleState( state );
+                        mButtons[i]->setVisible( create_visible );
+                }
+        }
+
+        if (mCheckSticky) mCheckSticky          ->setVisible( create_visible );
+        if (mCheckCopySelection) mCheckCopySelection    ->setVisible( create_visible );
+        if (mCheckCopyCenters) mCheckCopyCenters        ->setVisible( create_visible );
+        if (mCheckCopyRotates) mCheckCopyRotates        ->setVisible( create_visible );
+
+        if (mCheckCopyCenters) mCheckCopyCenters->setEnabled( mCheckCopySelection->get() );
+        if (mCheckCopyRotates) mCheckCopyRotates->setEnabled( mCheckCopySelection->get() );
+
+        // Land buttons
+        BOOL land_visible = (tool == gToolLand || tool == gToolParcel );
+
+        if (mBtnLand)   mBtnLand        ->setToggleState( land_visible );
+
+        //      mRadioEditLand  ->set( tool == gToolLand );
+        if (mRadioSelectLand)   mRadioSelectLand->set( tool == gToolParcel );
+
+        //      mRadioEditLand  ->setVisible( land_visible );
+        if (mRadioSelectLand)   mRadioSelectLand->setVisible( land_visible );
+
+        S32 dozer_mode = gSavedSettings.getS32("RadioLandBrushAction");
+        S32 dozer_size = gSavedSettings.getS32("RadioLandBrushSize");
+
+        if (mRadioDozerFlatten)
+        {
+                mRadioDozerFlatten      ->set( tool == gToolLand && dozer_mode == 0);
+                mRadioDozerFlatten      ->setVisible( land_visible );
+        }
+        if (mRadioDozerRaise)
+        {
+                mRadioDozerRaise        ->set( tool == gToolLand && dozer_mode == 1);
+                mRadioDozerRaise        ->setVisible( land_visible );
+        }
+        if (mRadioDozerLower)
+        {
+                mRadioDozerLower        ->set( tool == gToolLand && dozer_mode == 2);
+                mRadioDozerLower        ->setVisible( land_visible );
+        }
+        if (mRadioDozerSmooth)
+        {
+                mRadioDozerSmooth       ->set( tool == gToolLand && dozer_mode == 3);
+                mRadioDozerSmooth       ->setVisible( land_visible );
+        }
+        if (mRadioDozerNoise)
+        {
+                mRadioDozerNoise        ->set( tool == gToolLand && dozer_mode == 4);
+                mRadioDozerNoise        ->setVisible( land_visible );
+        }
+        if (mRadioDozerRevert)
+        {
+                mRadioDozerRevert       ->set( tool == gToolLand && dozer_mode == 5);
+                mRadioDozerRevert       ->setVisible( land_visible );
+        }
+        if (mComboDozerSize)
+        {
+                mComboDozerSize         ->setCurrentByIndex(dozer_size);
+                mComboDozerSize         ->setVisible( land_visible );
+                mComboDozerSize         ->setEnabled( tool == gToolLand );
+        }
+        if (mBtnApplyToSelection)
+        {
+                mBtnApplyToSelection->setVisible( land_visible );
+                mBtnApplyToSelection->setEnabled( land_visible && !gParcelMgr->selectionEmpty() && tool != gToolParcel);
+        }
+        if (mCheckShowOwners)
+        {
+                mCheckShowOwners        ->setVisible( land_visible );
+        }
+
+        //
+        // More panel visibility
+        //
+        BOOL show_more = gSavedSettings.getBOOL("ToolboxShowMore");
+
+        mTab->setVisible(show_more && tool != gToolLand && tool != gToolParcel);
+        mPanelLandInfo->setVisible(show_more && (tool == gToolLand || tool == gToolParcel));
+}
+
+
+// virtual
+BOOL LLFloaterTools::canClose()
+{
+        // don't close when quitting, so camera will stay put
+        return !gQuit;
+}
+
+// virtual
+void LLFloaterTools::onClose(bool app_quitting)
+{
+        setMinimized(FALSE);
+        setVisible(FALSE);
+        mTab->setVisible(FALSE);
+
+    // Different from handle_reset_view in that it doesn't actually 
+        //   move the camera if EditCameraMovement is not set.
+        gAgent.resetView(gSavedSettings.getBOOL("EditCameraMovement"));
+        
+        // exit component selection mode
+        gSelectMgr->promoteSelectionToRoot();
+        gSavedSettings.setBOOL("SelectLinkedSet", TRUE);
+
+        gViewerWindow->showCursor();
+
+        resetToolState();
+
+        // Switch back to basic toolset
+        gCurrentToolset = gBasicToolset;
+        gBasicToolset->selectFirstTool();
+        gToolMgr->useSelectedTool( gBasicToolset );
+}
+
+void LLFloaterTools::showMore(BOOL show_more)
+{
+        BOOL showing_more = gSavedSettings.getBOOL("ToolboxShowMore");
+        if (show_more == showing_more)
+        {
+                return;
+        }
+        
+        gSavedSettings.setBOOL("ToolboxShowMore", show_more);
+
+        // Visibility updated next frame - JC
+        // mTab->setVisible(show_more);
+
+        if (show_more)
+        {
+                reshape( mRect.getWidth(), mLargeHeight, TRUE);
+                translate( 0, mSmallHeight - mLargeHeight );
+                childSetVisible("button less", true);
+                childSetVisible("button more", false);
+        }
+        else
+        {
+                reshape( mRect.getWidth(), mSmallHeight, TRUE);
+                translate( 0, mLargeHeight - mSmallHeight );
+                childSetVisible("button less", false);
+                childSetVisible("button more", true);
+        }
+}
+
+void LLFloaterTools::showPanel(EInfoPanel panel)
+{
+        llassert(panel >= 0 && panel < PANEL_COUNT);
+        mTab->selectTabByName(PANEL_NAMES[panel]);
+        showMore(TRUE);
+}
+
+void click_show_more(void *userdata)
+{
+        LLFloaterTools *f = (LLFloaterTools *)userdata;
+        BOOL show_more = !gSavedSettings.getBOOL("ToolboxShowMore");
+        f->showMore( show_more );
+}
+
+void click_popup_info(void*)
+{
+//      gBuildView->setPropertiesPanelOpen(TRUE);
+}
+
+void click_popup_done(void*)
+{
+        handle_reset_view();
+}
+
+void click_popup_grab_drag(LLUICtrl*, void*)
+{
+        gGrabBtnVertical = FALSE;
+        gGrabBtnSpin = FALSE;
+}
+
+void click_popup_grab_lift(LLUICtrl*, void*)
+{
+        gGrabBtnVertical = TRUE;
+        gGrabBtnSpin = FALSE;
+}
+
+void click_popup_grab_spin(LLUICtrl*, void*)
+{
+        gGrabBtnVertical = FALSE;
+        gGrabBtnSpin = TRUE;
+}
+
+void commit_radio_zoom(LLUICtrl *, void*)
+{
+        gCameraBtnOrbit = FALSE;
+        gCameraBtnPan = FALSE;
+}
+
+void commit_radio_orbit(LLUICtrl *, void*)
+{
+        gCameraBtnOrbit = TRUE;
+        gCameraBtnPan = FALSE;
+}
+
+void commit_radio_pan(LLUICtrl *, void*)
+{
+        gCameraBtnOrbit = FALSE;
+        gCameraBtnPan = TRUE;
+}
+
+void commit_slider_zoom(LLUICtrl *ctrl, void*)
+{
+        LLVolumeSliderCtrl* slider = (LLVolumeSliderCtrl*)ctrl;
+        // renormalize value, since max "volume" level is 0.5 for some reason
+        F32 zoom_level = (F32)slider->getValue().asReal() * 2.f; // / 0.5f;
+        gAgent.setCameraZoomFraction(zoom_level);
+}
+
+void click_popup_rotate_left(void*)
+{
+        gSelectMgr->selectionRotateAroundZ( 45.f );
+        dialog_refresh_all();
+}
+
+void click_popup_rotate_reset(void*)
+{
+        gSelectMgr->selectionResetRotation();
+        dialog_refresh_all();
+}
+
+void click_popup_rotate_right(void*)
+{
+        gSelectMgr->selectionRotateAroundZ( -45.f );
+        dialog_refresh_all();
+}
+
+
+void click_popup_dozer_mode(LLUICtrl *, void *user)
+{
+        S32 show_owners = gSavedSettings.getBOOL("ShowParcelOwners");
+        S32 mode = (S32)(intptr_t) user;
+        gFloaterTools->setEditTool( gToolLand );
+        gSavedSettings.setS32("RadioLandBrushAction", mode);
+        gSavedSettings.setBOOL("ShowParcelOwners", show_owners);
+}
+
+void click_popup_dozer_size(LLUICtrl *, void *user)
+{
+        S32 size = (S32)(intptr_t) user;
+        gSavedSettings.setS32("RadioLandBrushSize", size);
+}
+
+void click_dozer_size(LLUICtrl *ctrl, void *user)
+{
+        S32 size = ((LLComboBox*) ctrl)->getCurrentIndex();
+        gSavedSettings.setS32("RadioLandBrushSize", size);
+}
+
+void click_apply_to_selection(void* user)
+{
+        gToolLand->modifyLandInSelectionGlobal();
+}
+
+void commit_select_tool(LLUICtrl *ctrl, void *data)
+{
+        S32 show_owners = gSavedSettings.getBOOL("ShowParcelOwners");
+        gFloaterTools->setEditTool(data);
+        gSavedSettings.setBOOL("ShowParcelOwners", show_owners);
+}
+
+void commit_select_component(LLUICtrl *ctrl, void *data)
+{
+        LLFloaterTools* floaterp = (LLFloaterTools*)data;
+
+        //forfeit focus
+        if (gFocusMgr.childHasKeyboardFocus(floaterp))
+        {
+                gFocusMgr.setKeyboardFocus(NULL, NULL);
+        }
+
+        BOOL select_individuals = floaterp->mCheckSelectIndividual->get();
+        gSavedSettings.setBOOL("SelectLinkedSet", !select_individuals);
+        floaterp->dirty();
+
+        if (select_individuals)
+        {
+                gSelectMgr->demoteSelectionToIndividuals();
+        }
+        else
+        {
+                gSelectMgr->promoteSelectionToRoot();
+        }
+}
+
+void commit_grid_mode(LLUICtrl *ctrl, void *data)   
+{   
+        LLComboBox* combo = (LLComboBox*)ctrl;   
+    
+        gSelectMgr->setGridMode((EGridMode)combo->getCurrentIndex());
+} 
+
+// static 
+void LLFloaterTools::setObjectType( void* data )
+{
+        LLPCode pcode = *(LLPCode*) data;
+        LLToolPlacer::setObjectType( pcode );
+        gSavedSettings.setBOOL("CreateToolCopySelection", FALSE);
+        gViewerWindow->setMouseCapture(NULL, NULL);
+}
+
+// static
+void LLFloaterTools::onClickGridOptions(void* data)
+{
+        //LLFloaterTools* floaterp = (LLFloaterTools*)data;
+        LLFloaterBuildOptions::show(NULL);
+        // RN: this makes grid options dependent on build tools window
+        //floaterp->addDependentFloater(LLFloaterBuildOptions::getInstance(), FALSE);
+}
+
+void LLFloaterTools::saveLastTool()
+{
+        mLastTool = gToolMgr->getCurrentTool( MASK_NONE );
+}
+
+void LLFloaterTools::setEditTool(void* tool_pointer)
+{
+        select_tool(tool_pointer);
+        if(gFloaterTools && tool_pointer != gToolNull)
+        {
+                gFloaterTools->saveLastTool();
+        }
+}
+
+void LLFloaterTools::onFocusReceived()
+{
+        select_tool(mLastTool);
+}
\ No newline at end of file