Singularity-Viewer/SingularityViewer
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity
Files
24ca32f9f724d455ad7537d1b1c04ea557e02a78
SingularityViewer/indra/newview/lltoolcomp.cpp
Lirusaito 30f5a3a162 Update qtoolalign (Fixes issue 704) 
- Removes shortcut ctrl-a for align tool
-- to avoid ctrl-a for select all text in UI controls messing up prim selection
- Adds llselectmgr select all function
-- to replace ctrl-a select all prims functionality that was a side effect of qtoolalign having this shortcut
- Adds toggle button (up/down arrow) to build floater for toggling display of the lower tab container area
-- This is to satisfy users who relied on ctrl-a to use align while the build floater was minimized and out of the way
- Syncs qtoolalign from Alchemy
2014-03-09 19:00:52 -04:00

865 lines
22 KiB
C++
Raw Blame History

/**
* @file lltoolcomp.cpp
* @brief Composite tools
*
* $LicenseInfo:firstyear=2001&license=viewerlgpl$
* Second Life Viewer Source Code
* Copyright (C) 2010, Linden Research, Inc.
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License as published by the Free Software Foundation;
* version 2.1 of the License only.
*
* This library is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with this library; if not, write to the Free Software
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
*
* Linden Research, Inc., 945 Battery Street, San Francisco, CA 94111 USA
* $/LicenseInfo$
*/
#include "llviewerprecompiledheaders.h"
#include "lltoolcomp.h"
#include "llgl.h"
#include "indra_constants.h"
#include "llmanip.h"
#include "llmaniprotate.h"
#include "llmanipscale.h"
#include "llmaniptranslate.h"
#include "llmenugl.h" // for right-click menu hack
#include "llselectmgr.h"
#include "lltoolfocus.h"
#include "lltoolgrab.h"
#include "lltoolgun.h"
#include "lltoolmgr.h"
#include "lltoolselectrect.h"
#include "lltoolplacer.h"
#include "llviewercamera.h" // <exodus/>
#include "llviewermenu.h"
#include "llviewerobject.h"
#include "llviewerwindow.h"
#include "llagent.h"
#include "llagentcamera.h"
#include "llfloatertools.h"
#include "llviewercontrol.h"
const S32 BUTTON_HEIGHT = 16;
const S32 BUTTON_WIDTH_SMALL = 32;
const S32 BUTTON_WIDTH_BIG = 48;
const S32 HPAD = 4;
extern LLControlGroup gSavedSettings;
// we use this in various places instead of NULL
static LLTool* sNullTool = new LLTool(std::string("null"), NULL);
//-----------------------------------------------------------------------
// LLToolComposite
//static
void LLToolComposite::setCurrentTool( LLTool* new_tool )
{
if( mCur != new_tool )
{
if(new_tool)
lldebugs << "Current Tool: " << new_tool->getName() << llendl;
if( mSelected )
{
mCur->handleDeselect();
mCur = new_tool;
mCur->handleSelect();
}
else
{
mCur = new_tool;
}
}
}
LLToolComposite::LLToolComposite(const std::string& name)
: LLTool(name),
mCur(sNullTool),
mDefault(sNullTool),
mSelected(FALSE),
mMouseDown(FALSE), mManip(NULL), mSelectRect(NULL)
{
}
// Returns to the default tool
BOOL LLToolComposite::handleMouseUp(S32 x, S32 y, MASK mask)
{
BOOL handled = mCur->handleMouseUp( x, y, mask );
if( handled )
{
setCurrentTool( mDefault );
}
return handled;
}
void LLToolComposite::onMouseCaptureLost()
{
mCur->onMouseCaptureLost();
setCurrentTool( mDefault );
}
BOOL LLToolComposite::isSelecting()
{
return mCur == mSelectRect;
}
void LLToolComposite::handleSelect()
{
if (!gSavedSettings.getBOOL("EditLinkedParts"))
{
LLSelectMgr::getInstance()->promoteSelectionToRoot();
}
mCur = mDefault;
mCur->handleSelect();
mSelected = TRUE;
}
//----------------------------------------------------------------------------
// LLToolCompInspect
//----------------------------------------------------------------------------
LLToolCompInspect::LLToolCompInspect()
: LLToolComposite(std::string("Inspect"))
{
mSelectRect = new LLToolSelectRect(this);
mDefault = mSelectRect;
}
LLToolCompInspect::~LLToolCompInspect()
{
delete mSelectRect;
mSelectRect = NULL;
}
BOOL LLToolCompInspect::handleMouseDown(S32 x, S32 y, MASK mask)
{
mMouseDown = TRUE;
gViewerWindow->pickAsync(x, y, mask, pickCallback);
return TRUE;
}
void LLToolCompInspect::pickCallback(const LLPickInfo& pick_info)
{
LLViewerObject* hit_obj = pick_info.getObject();
if (!LLToolCompInspect::getInstance()->mMouseDown)
{
// fast click on object, but mouse is already up...just do select
LLToolCompInspect::getInstance()->mSelectRect->handleObjectSelection(pick_info, gSavedSettings.getBOOL("EditLinkedParts"), FALSE);
return;
}
if( hit_obj )
{
if (LLSelectMgr::getInstance()->getSelection()->getObjectCount())
{
LLEditMenuHandler::gEditMenuHandler = LLSelectMgr::getInstance();
}
LLToolCompInspect::getInstance()->setCurrentTool( LLToolCompInspect::getInstance()->mSelectRect );
LLToolCompInspect::getInstance()->mSelectRect->handlePick( pick_info );
}
else
{
LLToolCompInspect::getInstance()->setCurrentTool( LLToolCompInspect::getInstance()->mSelectRect );
LLToolCompInspect::getInstance()->mSelectRect->handlePick( pick_info );
}
}
BOOL LLToolCompInspect::handleDoubleClick(S32 x, S32 y, MASK mask)
{
return TRUE;
}
//----------------------------------------------------------------------------
// LLToolCompTranslate
//----------------------------------------------------------------------------
LLToolCompTranslate::LLToolCompTranslate()
: LLToolComposite(std::string("Move"))
{
mManip = new LLManipTranslate(this);
mSelectRect = new LLToolSelectRect(this);
mCur = mManip;
mDefault = mManip;
}
LLToolCompTranslate::~LLToolCompTranslate()
{
delete mManip;
mManip = NULL;
delete mSelectRect;
mSelectRect = NULL;
}
BOOL LLToolCompTranslate::handleHover(S32 x, S32 y, MASK mask)
{
if( !mCur->hasMouseCapture() )
{
setCurrentTool( mManip );
}
return mCur->handleHover( x, y, mask );
}
BOOL LLToolCompTranslate::handleMouseDown(S32 x, S32 y, MASK mask)
{
mMouseDown = TRUE;
gViewerWindow->pickAsync(x, y, mask, pickCallback, TRUE);
return TRUE;
}
void LLToolCompTranslate::pickCallback(const LLPickInfo& pick_info)
{
LLViewerObject* hit_obj = pick_info.getObject();
LLToolCompTranslate::getInstance()->mManip->highlightManipulators(pick_info.mMousePt.mX, pick_info.mMousePt.mY);
if (!LLToolCompTranslate::getInstance()->mMouseDown)
{
// fast click on object, but mouse is already up...just do select
LLToolCompTranslate::getInstance()->mSelectRect->handleObjectSelection(pick_info, gSavedSettings.getBOOL("EditLinkedParts"), FALSE);
return;
}
if( hit_obj || LLToolCompTranslate::getInstance()->mManip->getHighlightedPart() != LLManip::LL_NO_PART )
{
if (LLToolCompTranslate::getInstance()->mManip->getSelection()->getObjectCount())
{
LLEditMenuHandler::gEditMenuHandler = LLSelectMgr::getInstance();
}
BOOL can_move = LLToolCompTranslate::getInstance()->mManip->canAffectSelection();
if( LLManip::LL_NO_PART != LLToolCompTranslate::getInstance()->mManip->getHighlightedPart() && can_move)
{
LLToolCompTranslate::getInstance()->setCurrentTool( LLToolCompTranslate::getInstance()->mManip );
LLToolCompTranslate::getInstance()->mManip->handleMouseDownOnPart( pick_info.mMousePt.mX, pick_info.mMousePt.mY, pick_info.mKeyMask );
}
else
{
LLToolCompTranslate::getInstance()->setCurrentTool( LLToolCompTranslate::getInstance()->mSelectRect );
LLToolCompTranslate::getInstance()->mSelectRect->handlePick( pick_info );
// *TODO: add toggle to trigger old click-drag functionality
// LLToolCompTranslate::getInstance()->mManip->handleMouseDownOnPart( XY_part, x, y, mask);
}
}
else
{
LLToolCompTranslate::getInstance()->setCurrentTool( LLToolCompTranslate::getInstance()->mSelectRect );
LLToolCompTranslate::getInstance()->mSelectRect->handlePick( pick_info );
}
}
BOOL LLToolCompTranslate::handleMouseUp(S32 x, S32 y, MASK mask)
{
mMouseDown = FALSE;
return LLToolComposite::handleMouseUp(x, y, mask);
}
LLTool* LLToolCompTranslate::getOverrideTool(MASK mask)
{
if (mask == MASK_CONTROL)
{
return LLToolCompRotate::getInstance();
}
else if (mask == (MASK_CONTROL | MASK_SHIFT))
{
return LLToolCompScale::getInstance();
}
return LLToolComposite::getOverrideTool(mask);
}
BOOL LLToolCompTranslate::handleDoubleClick(S32 x, S32 y, MASK mask)
{
if (mManip->getSelection()->isEmpty() && mManip->getHighlightedPart() == LLManip::LL_NO_PART)
{
// You should already have an object selected from the mousedown.
// If so, show its properties
gFloaterTools->showPanel(LLFloaterTools::PANEL_CONTENTS);
return TRUE;
}
// Nothing selected means the first mouse click was probably
// bad, so try again.
return FALSE;
}
void LLToolCompTranslate::render()
{
mCur->render(); // removing this will not draw the RGB arrows and guidelines
if( mCur != mManip )
{
LLGLDepthTest gls_depth(GL_TRUE, GL_FALSE);
mManip->renderGuidelines();
}
}
//-----------------------------------------------------------------------
// LLToolCompScale
LLToolCompScale::LLToolCompScale()
: LLToolComposite(std::string("Stretch"))
{
mManip = new LLManipScale(this);
mSelectRect = new LLToolSelectRect(this);
mCur = mManip;
mDefault = mManip;
}
LLToolCompScale::~LLToolCompScale()
{
delete mManip;
delete mSelectRect;
}
BOOL LLToolCompScale::handleHover(S32 x, S32 y, MASK mask)
{
if( !mCur->hasMouseCapture() )
{
setCurrentTool(mManip );
}
return mCur->handleHover( x, y, mask );
}
BOOL LLToolCompScale::handleMouseDown(S32 x, S32 y, MASK mask)
{
mMouseDown = TRUE;
gViewerWindow->pickAsync(x, y, mask, pickCallback);
return TRUE;
}
void LLToolCompScale::pickCallback(const LLPickInfo& pick_info)
{
LLViewerObject* hit_obj = pick_info.getObject();
LLToolCompScale::getInstance()->mManip->highlightManipulators(pick_info.mMousePt.mX, pick_info.mMousePt.mY);
if (!LLToolCompScale::getInstance()->mMouseDown)
{
// fast click on object, but mouse is already up...just do select
LLToolCompScale::getInstance()->mSelectRect->handleObjectSelection(pick_info, gSavedSettings.getBOOL("EditLinkedParts"), FALSE);
return;
}
if( hit_obj || LLToolCompScale::getInstance()->mManip->getHighlightedPart() != LLManip::LL_NO_PART)
{
if (LLToolCompScale::getInstance()->mManip->getSelection()->getObjectCount())
{
LLEditMenuHandler::gEditMenuHandler = LLSelectMgr::getInstance();
}
if( LLManip::LL_NO_PART != LLToolCompScale::getInstance()->mManip->getHighlightedPart() )
{
LLToolCompScale::getInstance()->setCurrentTool( LLToolCompScale::getInstance()->mManip );
LLToolCompScale::getInstance()->mManip->handleMouseDownOnPart( pick_info.mMousePt.mX, pick_info.mMousePt.mY, pick_info.mKeyMask );
}
else
{
LLToolCompScale::getInstance()->setCurrentTool( LLToolCompScale::getInstance()->mSelectRect );
LLToolCompScale::getInstance()->mSelectRect->handlePick( pick_info );
}
}
else
{
LLToolCompScale::getInstance()->setCurrentTool( LLToolCompScale::getInstance()->mSelectRect );
LLToolCompScale::getInstance()->mSelectRect->handlePick( pick_info );
}
}
BOOL LLToolCompScale::handleMouseUp(S32 x, S32 y, MASK mask)
{
mMouseDown = FALSE;
return LLToolComposite::handleMouseUp(x, y, mask);
}
LLTool* LLToolCompScale::getOverrideTool(MASK mask)
{
if (mask == MASK_CONTROL)
{
return LLToolCompRotate::getInstance();
}
return LLToolComposite::getOverrideTool(mask);
}
BOOL LLToolCompScale::handleDoubleClick(S32 x, S32 y, MASK mask)
{
if (!mManip->getSelection()->isEmpty() && mManip->getHighlightedPart() == LLManip::LL_NO_PART)
{
// You should already have an object selected from the mousedown.
// If so, show its properties
gFloaterTools->showPanel(LLFloaterTools::PANEL_CONTENTS);
//gBuildView->setPropertiesPanelOpen(TRUE);
return TRUE;
}
else
{
// Nothing selected means the first mouse click was probably
// bad, so try again.
return handleMouseDown(x, y, mask);
}
}
void LLToolCompScale::render()
{
mCur->render();
if( mCur != mManip )
{
LLGLDepthTest gls_depth(GL_TRUE, GL_FALSE);
mManip->renderGuidelines();
}
}
//-----------------------------------------------------------------------
// LLToolCompCreate
LLToolCompCreate::LLToolCompCreate()
: LLToolComposite(std::string("Create"))
{
mPlacer = new LLToolPlacer();
mSelectRect = new LLToolSelectRect(this);
mCur = mPlacer;
mDefault = mPlacer;
mObjectPlacedOnMouseDown = FALSE;
}
LLToolCompCreate::~LLToolCompCreate()
{
delete mPlacer;
delete mSelectRect;
}
BOOL LLToolCompCreate::handleMouseDown(S32 x, S32 y, MASK mask)
{
BOOL handled = FALSE;
mMouseDown = TRUE;
if ( (mask == MASK_SHIFT) || (mask == MASK_CONTROL) )
{
gViewerWindow->pickAsync(x, y, mask, pickCallback);
handled = TRUE;
}
else
{
setCurrentTool( mPlacer );
handled = mPlacer->placeObject( x, y, mask );
}
mObjectPlacedOnMouseDown = TRUE;
return handled;
}
void LLToolCompCreate::pickCallback(const LLPickInfo& pick_info)
{
// *NOTE: We mask off shift and control, so you cannot
// multi-select multiple objects with the create tool.
MASK mask = (pick_info.mKeyMask & ~MASK_SHIFT);
mask = (mask & ~MASK_CONTROL);
LLToolCompCreate::getInstance()->setCurrentTool( LLToolCompCreate::getInstance()->mSelectRect );
LLToolCompCreate::getInstance()->mSelectRect->handlePick( pick_info );
}
BOOL LLToolCompCreate::handleDoubleClick(S32 x, S32 y, MASK mask)
{
return handleMouseDown(x, y, mask);
}
BOOL LLToolCompCreate::handleMouseUp(S32 x, S32 y, MASK mask)
{
BOOL handled = FALSE;
if ( mMouseDown && !mObjectPlacedOnMouseDown && !(mask == MASK_SHIFT) && !(mask == MASK_CONTROL) )
{
setCurrentTool( mPlacer );
handled = mPlacer->placeObject( x, y, mask );
}
mObjectPlacedOnMouseDown = FALSE;
mMouseDown = FALSE;
if (!handled)
{
handled = LLToolComposite::handleMouseUp(x, y, mask);
}
return handled;
}
//-----------------------------------------------------------------------
// LLToolCompRotate
LLToolCompRotate::LLToolCompRotate()
: LLToolComposite(std::string("Rotate"))
{
mManip = new LLManipRotate(this);
mSelectRect = new LLToolSelectRect(this);
mCur = mManip;
mDefault = mManip;
}
LLToolCompRotate::~LLToolCompRotate()
{
delete mManip;
delete mSelectRect;
}
BOOL LLToolCompRotate::handleHover(S32 x, S32 y, MASK mask)
{
if( !mCur->hasMouseCapture() )
{
setCurrentTool( mManip );
}
return mCur->handleHover( x, y, mask );
}
BOOL LLToolCompRotate::handleMouseDown(S32 x, S32 y, MASK mask)
{
mMouseDown = TRUE;
gViewerWindow->pickAsync(x, y, mask, pickCallback);
return TRUE;
}
void LLToolCompRotate::pickCallback(const LLPickInfo& pick_info)
{
LLViewerObject* hit_obj = pick_info.getObject();
LLToolCompRotate::getInstance()->mManip->highlightManipulators(pick_info.mMousePt.mX, pick_info.mMousePt.mY);
if (!LLToolCompRotate::getInstance()->mMouseDown)
{
// fast click on object, but mouse is already up...just do select
LLToolCompRotate::getInstance()->mSelectRect->handleObjectSelection(pick_info, gSavedSettings.getBOOL("EditLinkedParts"), FALSE);
return;
}
if( hit_obj || LLToolCompRotate::getInstance()->mManip->getHighlightedPart() != LLManip::LL_NO_PART)
{
if (LLToolCompRotate::getInstance()->mManip->getSelection()->getObjectCount())
{
LLEditMenuHandler::gEditMenuHandler = LLSelectMgr::getInstance();
}
if( LLManip::LL_NO_PART != LLToolCompRotate::getInstance()->mManip->getHighlightedPart() )
{
LLToolCompRotate::getInstance()->setCurrentTool( LLToolCompRotate::getInstance()->mManip );
LLToolCompRotate::getInstance()->mManip->handleMouseDownOnPart( pick_info.mMousePt.mX, pick_info.mMousePt.mY, pick_info.mKeyMask );
}
else
{
LLToolCompRotate::getInstance()->setCurrentTool( LLToolCompRotate::getInstance()->mSelectRect );
LLToolCompRotate::getInstance()->mSelectRect->handlePick( pick_info );
}
}
else
{
LLToolCompRotate::getInstance()->setCurrentTool( LLToolCompRotate::getInstance()->mSelectRect );
LLToolCompRotate::getInstance()->mSelectRect->handlePick( pick_info );
}
}
BOOL LLToolCompRotate::handleMouseUp(S32 x, S32 y, MASK mask)
{
mMouseDown = FALSE;
return LLToolComposite::handleMouseUp(x, y, mask);
}
LLTool* LLToolCompRotate::getOverrideTool(MASK mask)
{
if (mask == (MASK_CONTROL | MASK_SHIFT))
{
return LLToolCompScale::getInstance();
}
return LLToolComposite::getOverrideTool(mask);
}
BOOL LLToolCompRotate::handleDoubleClick(S32 x, S32 y, MASK mask)
{
if (!mManip->getSelection()->isEmpty() && mManip->getHighlightedPart() == LLManip::LL_NO_PART)
{
// You should already have an object selected from the mousedown.
// If so, show its properties
gFloaterTools->showPanel(LLFloaterTools::PANEL_CONTENTS);
//gBuildView->setPropertiesPanelOpen(TRUE);
return TRUE;
}
else
{
// Nothing selected means the first mouse click was probably
// bad, so try again.
return handleMouseDown(x, y, mask);
}
}
void LLToolCompRotate::render()
{
mCur->render();
if( mCur != mManip )
{
LLGLDepthTest gls_depth(GL_TRUE, GL_FALSE);
mManip->renderGuidelines();
}
}
//-----------------------------------------------------------------------
// LLToolCompGun
LLToolCompGun::LLToolCompGun()
: LLToolComposite(std::string("Mouselook"))
, mRightMouseButton(false), mMenuShown(false), mTimerFOV(), mOriginalFOV(), mStartFOV(), mTargetFOV() // <exodus/>
{
mGun = new LLToolGun(this);
mGrab = new LLToolGrab(this);
mNull = sNullTool;
setCurrentTool(mGun);
mDefault = mGun;
// <exodus>
mTimerFOV.stop();
// </exodus>
}
LLToolCompGun::~LLToolCompGun()
{
delete mGun;
mGun = NULL;
delete mGrab;
mGrab = NULL;
// don't delete a static object
// delete mNull;
mNull = NULL;
}
BOOL LLToolCompGun::handleHover(S32 x, S32 y, MASK mask)
{
// *NOTE: This hack is here to make mouselook kick in again after
// item selected from context menu.
if ( mCur == mNull && !gPopupMenuView->getVisible() )
{
LLSelectMgr::getInstance()->deselectAll();
setCurrentTool( (LLTool*) mGrab );
}
// Note: if the tool changed, we can't delegate the current mouse event
// after the change because tools can modify the mouse during selection and deselection.
// Instead we let the current tool handle the event and then make the change.
// The new tool will take effect on the next frame.
mCur->handleHover( x, y, mask );
// If mouse button not down...
if( !gViewerWindow->getLeftMouseDown())
{
// let ALT switch from gun to grab
if ( mCur == mGun && (mask & MASK_ALT) )
{
setCurrentTool( (LLTool*) mGrab );
}
else if ( mCur == mGrab && !(mask & MASK_ALT) )
{
setCurrentTool( (LLTool*) mGun );
setMouseCapture(TRUE);
}
}
return TRUE;
}
BOOL LLToolCompGun::handleMouseDown(S32 x, S32 y, MASK mask)
{
// if the left button is grabbed, don't put up the pie menu
if (gAgent.leftButtonGrabbed())
{
gAgent.setControlFlags(AGENT_CONTROL_ML_LBUTTON_DOWN);
return FALSE;
}
// On mousedown, start grabbing
gGrabTransientTool = this;
LLToolMgr::getInstance()->getCurrentToolset()->selectTool( (LLTool*) mGrab );
return LLToolGrab::getInstance()->handleMouseDown(x, y, mask);
}
BOOL LLToolCompGun::handleDoubleClick(S32 x, S32 y, MASK mask)
{
// if the left button is grabbed, don't put up the pie menu
if (gAgent.leftButtonGrabbed())
{
gAgent.setControlFlags(AGENT_CONTROL_ML_LBUTTON_DOWN);
return FALSE;
}
// On mousedown, start grabbing
gGrabTransientTool = this;
LLToolMgr::getInstance()->getCurrentToolset()->selectTool( (LLTool*) mGrab );
return LLToolGrab::getInstance()->handleDoubleClick(x, y, mask);
}
/* Singu Note: Moved to bottom, upstream is Exodus
BOOL LLToolCompGun::handleRightMouseDown(S32 x, S32 y, MASK mask)
*/
BOOL LLToolCompGun::handleMouseUp(S32 x, S32 y, MASK mask)
{
gAgent.setControlFlags(AGENT_CONTROL_ML_LBUTTON_UP);
setCurrentTool( (LLTool*) mGun );
return TRUE;
}
void LLToolCompGun::onMouseCaptureLost()
{
if (mComposite)
{
mComposite->onMouseCaptureLost();
return;
}
mCur->onMouseCaptureLost();
}
void LLToolCompGun::handleSelect()
{
LLToolComposite::handleSelect();
setMouseCapture(TRUE);
}
void LLToolCompGun::handleDeselect()
{
LLToolComposite::handleDeselect();
if (mRightMouseButton || mTimerFOV.getStarted()) // Singu Note: Load Default FOV if we were zoomed in
{
LLViewerCamera::getInstance()->loadDefaultFOV();
mRightMouseButton = false;
}
setMouseCapture(FALSE);
}
// <exodus>
BOOL LLToolCompGun::handleRightMouseUp(S32 x, S32 y, MASK mask)
{
// Singu Note: Beware the alt-click menu
if (mRightMouseButton)
{
mRightMouseButton = false;
mStartFOV = LLViewerCamera::getInstance()->getDefaultFOV();
mTargetFOV = mOriginalFOV;
mTimerFOV.start();
}
if (mMenuShown)
{
mMenuShown = false;
return LLToolComposite::handleRightMouseUp(x, y, mask);
}
return TRUE;
}
BOOL LLToolCompGun::handleRightMouseDown(S32 x, S32 y, MASK mask)
{
// Singu Note: Beware the alt-click menu
if (gSavedSettings.getBOOL("LiruMouselookMenu") && mask & MASK_ALT)
{
mMenuShown = true;
return false;
}
mRightMouseButton = true;
if(!mTimerFOV.getStarted())
{
mStartFOV = LLViewerCamera::getInstance()->getAndSaveDefaultFOV();
mOriginalFOV = mStartFOV;
}
else mStartFOV = LLViewerCamera::getInstance()->getDefaultFOV();
mTargetFOV = gSavedSettings.getF32("ExodusAlternativeFOV");
mTimerFOV.start();
return TRUE;
}
BOOL LLToolCompGun::handleScrollWheel(S32 x, S32 y, S32 clicks)
{
if (mRightMouseButton)
{
mStartFOV = LLViewerCamera::getInstance()->getDefaultFOV();
gSavedSettings.setF32(
"ExodusAlternativeFOV",
mTargetFOV = clicks > 0 ?
llclamp(mTargetFOV += (0.05f * clicks), 0.1f, 3.0f) :
llclamp(mTargetFOV -= (0.05f * -clicks), 0.1f, 3.0f)
);
mTimerFOV.start();
}
else if (clicks > 0) gAgentCamera.changeCameraToDefault();
return TRUE;
}
// Zoom related stuff...
void LLToolCompGun::draw()
{
if (mTimerFOV.getStarted())
{
if (!LLViewerCamera::getInstance()->mSavedFOVLoaded && mStartFOV != mTargetFOV)
{
F32 timer = mTimerFOV.getElapsedTimeF32();
if (timer > 0.15f)
{
LLViewerCamera::getInstance()->setDefaultFOV(mTargetFOV);
mTimerFOV.stop();
}
else LLViewerCamera::getInstance()->setDefaultFOV(lerp(mStartFOV, mTargetFOV, timer * 6.66f));
}
else mTimerFOV.stop();
}
LLToolComposite::draw(); // Singu Note: We call parent here, instead of being clueless and adding to LLViewerWindow::draw for crosshairs and such
}
// </exodus>
Reference in New Issue View Git Blame Copy Permalink