mirror of
https://github.com/TorqueGameEngines/Torque3D.git
synced 2026-01-20 12:44:46 +00:00
2002d74b78
Many instances of a function or expression being used repeatedly, which can lower performance. Fixed it in these cases by creating on local var, reference or pointer that's used instead.
322 lines
9.9 KiB
C++
322 lines
9.9 KiB
C++
//-----------------------------------------------------------------------------
|
|
// Copyright (c) 2012 GarageGames, LLC
|
|
//
|
|
// Permission is hereby granted, free of charge, to any person obtaining a copy
|
|
// of this software and associated documentation files (the "Software"), to
|
|
// deal in the Software without restriction, including without limitation the
|
|
// rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
|
|
// sell copies of the Software, and to permit persons to whom the Software is
|
|
// furnished to do so, subject to the following conditions:
|
|
//
|
|
// The above copyright notice and this permission notice shall be included in
|
|
// all copies or substantial portions of the Software.
|
|
//
|
|
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
|
|
// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
|
|
// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
|
|
// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
|
|
// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
|
|
// FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
|
|
// IN THE SOFTWARE.
|
|
//-----------------------------------------------------------------------------
|
|
|
|
#include "console/console.h"
|
|
#include "console/consoleTypes.h"
|
|
#include "console/engineAPI.h"
|
|
#include "gfx/gfxDevice.h"
|
|
#include "gfx/gfxDrawUtil.h"
|
|
|
|
#include "gui/editor/guiRectHandles.h"
|
|
|
|
IMPLEMENT_CONOBJECT(GuiRectHandles);
|
|
|
|
ConsoleDocClass( GuiRectHandles,
|
|
"@brief Draws a box with handles for the user to manipulate.\n\n"
|
|
"Editor use only.\n\n"
|
|
"@internal"
|
|
);
|
|
|
|
//--------------------------------------------------------------------------
|
|
GuiRectHandles::GuiRectHandles() : GuiControl()
|
|
{
|
|
mHandleRect.set(0.0f, 0.0f, 1.0f, 1.0f);
|
|
mHandleSize = 10;
|
|
mUseCustomColor = false;
|
|
mHandleColor.set(100,100,100);
|
|
mHitHandle = 0;
|
|
}
|
|
|
|
GuiRectHandles::~GuiRectHandles()
|
|
{
|
|
}
|
|
|
|
//--------------------------------------------------------------------------
|
|
void GuiRectHandles::initPersistFields()
|
|
{
|
|
addField("handleRect", TypeRectF, Offset(mHandleRect, GuiRectHandles), "RectF of handle's box." );
|
|
addField("handleSize", TypeS32, Offset(mHandleSize, GuiRectHandles), "Size of handles in pixels." );
|
|
addField("useCustomColor", TypeBool, Offset(mUseCustomColor, GuiRectHandles), "Use given custom color for handles." );
|
|
addField("handleColor", TypeColorI, Offset(mHandleColor, GuiRectHandles), "Use given custom color for handles." );
|
|
|
|
Parent::initPersistFields();
|
|
}
|
|
|
|
//--------------------------------------------------------------------------
|
|
|
|
void GuiRectHandles::onMouseUp(const GuiEvent &event)
|
|
{
|
|
mHitHandle = 0;
|
|
}
|
|
|
|
void GuiRectHandles::onMouseDown(const GuiEvent &event)
|
|
{
|
|
// The handles range from 0-1, so scale to fit within the
|
|
// control's bounds.
|
|
const Point2I& extent = getExtent();
|
|
Point2I pos(extent.x*mHandleRect.point.x, extent.y*mHandleRect.point.y);
|
|
Point2I size(extent.x*mHandleRect.extent.x, extent.y*mHandleRect.extent.y);
|
|
RectI box(pos, size);
|
|
|
|
Point2I localMousePoint = globalToLocalCoord(event.mousePoint);
|
|
|
|
// Check if mouse is within handle rect
|
|
if(!box.pointInRect(localMousePoint))
|
|
{
|
|
mHitHandle = 0;
|
|
return;
|
|
}
|
|
|
|
Point2I normalizedMouse = localMousePoint - pos;
|
|
Point2I halfSize = size / 2;
|
|
S32 halfHandleSize = mHandleSize / 2;
|
|
if(normalizedMouse.y < mHandleSize)
|
|
{
|
|
// Top handles
|
|
if(normalizedMouse.x < mHandleSize)
|
|
mHitHandle = 1;
|
|
else if(normalizedMouse.x >= (size.x-mHandleSize))
|
|
mHitHandle = 3;
|
|
else if(normalizedMouse.x >= (halfSize.x-halfHandleSize) && normalizedMouse.x < (halfSize.x+halfHandleSize))
|
|
mHitHandle = 2;
|
|
}
|
|
else if(normalizedMouse.y >= (size.y-mHandleSize))
|
|
{
|
|
// Bottom handles
|
|
if(normalizedMouse.x < mHandleSize)
|
|
mHitHandle = 7;
|
|
else if(normalizedMouse.x >= (size.x-mHandleSize))
|
|
mHitHandle = 5;
|
|
else if(normalizedMouse.x >= (halfSize.x-halfHandleSize) && normalizedMouse.x < (halfSize.x+halfHandleSize))
|
|
mHitHandle = 6;
|
|
}
|
|
else if(normalizedMouse.y >= (halfSize.y-halfHandleSize) && normalizedMouse.y < (halfSize.y+halfHandleSize))
|
|
{
|
|
// Middle handles
|
|
if(normalizedMouse.x < mHandleSize)
|
|
mHitHandle = 8;
|
|
else if(normalizedMouse.x >= (size.x-mHandleSize))
|
|
mHitHandle = 4;
|
|
else if(normalizedMouse.x >= (halfSize.x-halfHandleSize) && normalizedMouse.x < (halfSize.x+halfHandleSize))
|
|
mHitHandle = 9;
|
|
}
|
|
|
|
mHitPoint = localMousePoint;
|
|
}
|
|
|
|
void GuiRectHandles::onMouseDragged(const GuiEvent &event)
|
|
{
|
|
if(mHitHandle == 0)
|
|
return;
|
|
|
|
// The handles range from 0-1, so scale to fit within the
|
|
// control's bounds.
|
|
const Point2I& extent = getExtent();
|
|
|
|
Point2I localMousePoint = globalToLocalCoord(event.mousePoint);
|
|
|
|
Point2I diffI = localMousePoint - mHitPoint;
|
|
Point2F diffF(diffI.x/F32(extent.x), diffI.y/F32(extent.y));
|
|
|
|
RectF box(mHandleRect);
|
|
bool postMoveExtentX = false;
|
|
bool postMoveExtentY = false;
|
|
bool keepExtent = false;
|
|
|
|
switch(mHitHandle)
|
|
{
|
|
case 1:
|
|
{
|
|
// Top left
|
|
box.point += diffF;
|
|
postMoveExtentX = true;
|
|
postMoveExtentY = true;
|
|
break;
|
|
}
|
|
|
|
case 2:
|
|
{
|
|
// Top middle
|
|
box.point.y += diffF.y;
|
|
postMoveExtentY = true;
|
|
break;
|
|
}
|
|
|
|
case 3:
|
|
{
|
|
// Top right
|
|
box.point.y += diffF.y;
|
|
box.extent.x += diffF.x;
|
|
postMoveExtentY = true;
|
|
break;
|
|
}
|
|
|
|
case 4:
|
|
{
|
|
// Middle right
|
|
box.extent.x += diffF.x;
|
|
break;
|
|
}
|
|
|
|
case 5:
|
|
{
|
|
// Bottom right
|
|
box.extent += diffF;
|
|
break;
|
|
}
|
|
|
|
case 6:
|
|
{
|
|
// Bottom middle
|
|
box.extent.y += diffF.y;
|
|
break;
|
|
}
|
|
|
|
case 7:
|
|
{
|
|
// Bottom left
|
|
box.point.x += diffF.x;
|
|
box.extent.y += diffF.y;
|
|
postMoveExtentX = true;
|
|
break;
|
|
}
|
|
|
|
case 8:
|
|
{
|
|
// Middle left
|
|
box.point.x += diffF.x;
|
|
postMoveExtentX = true;
|
|
break;
|
|
}
|
|
|
|
case 9:
|
|
{
|
|
// Centre
|
|
box.point += diffF;
|
|
keepExtent = true;
|
|
break;
|
|
}
|
|
|
|
default:
|
|
break;
|
|
}
|
|
|
|
// Position limits
|
|
if(box.point.x < 0.0f)
|
|
box.point.x = 0.0f;
|
|
else if(box.point.x > 1.0f)
|
|
box.point.x = 1.0f;
|
|
|
|
if(box.point.y < 0.0f)
|
|
box.point.y = 0.0f;
|
|
else if(box.point.y > 1.0f)
|
|
box.point.y = 1.0f;
|
|
|
|
// Move any extent to counter a change in handle position. Do this
|
|
// after the limits above to make sure the extent doesn't accidentally
|
|
// grow when the position is clamped.
|
|
if(postMoveExtentX)
|
|
box.extent.x += mHandleRect.point.x - box.point.x;
|
|
if(postMoveExtentY)
|
|
box.extent.y += mHandleRect.point.y - box.point.y;
|
|
|
|
// Extent limits
|
|
if(box.extent.x < 0.0f)
|
|
box.extent.x = 0.0f;
|
|
else if(box.extent.x > 1.0f)
|
|
box.extent.x = 1.0f;
|
|
if(box.point.x+box.extent.x > 1.0f)
|
|
{
|
|
if(keepExtent)
|
|
box.point.x = 1.0f-box.extent.x;
|
|
else
|
|
box.extent.x = 1.0f-box.point.x;
|
|
}
|
|
|
|
if(box.extent.y < 0.0f)
|
|
box.extent.y = 0.0f;
|
|
else if(box.extent.y > 1.0f)
|
|
box.extent.y = 1.0f;
|
|
if(box.point.y+box.extent.y > 1.0f)
|
|
{
|
|
if(keepExtent)
|
|
box.point.y = 1.0f-box.extent.y;
|
|
else
|
|
box.extent.y = 1.0f-box.point.y;
|
|
}
|
|
|
|
mHandleRect = box;
|
|
mHitPoint = localMousePoint;
|
|
|
|
if( isMethod( "onHandleRectChange" ) )
|
|
Con::executef(this, "onHandleRectChange" );
|
|
}
|
|
|
|
//--------------------------------------------------------------------------
|
|
void GuiRectHandles::onRender(Point2I offset, const RectI &updateRect)
|
|
{
|
|
Parent::onRender( offset, updateRect );
|
|
|
|
ColorI handleColor = mProfile->mBorderColor;
|
|
if(mUseCustomColor)
|
|
handleColor = mHandleColor;
|
|
|
|
// The handles range from 0-1, so scale to fit within the
|
|
// control's bounds.
|
|
const Point2I& extent = getExtent();
|
|
Point2I pos(extent.x*mHandleRect.point.x, extent.y*mHandleRect.point.y);
|
|
Point2I size(extent.x*mHandleRect.extent.x, extent.y*mHandleRect.extent.y);
|
|
RectI box(offset+pos, size);
|
|
|
|
GFXDrawUtil* drawUtil = GFX->getDrawUtil();
|
|
|
|
// Draw border
|
|
drawUtil->drawRect(box, handleColor);
|
|
|
|
// Draw each handle
|
|
Point2I handleSize(mHandleSize, mHandleSize);
|
|
RectI handleRect(box.point, handleSize);
|
|
drawUtil->drawRectFill(handleRect, handleColor); // Upper left
|
|
handleRect.point = Point2I(box.point.x+size.x-handleSize.x, box.point.y);
|
|
drawUtil->drawRectFill(handleRect, handleColor); // Upper right
|
|
handleRect.point = Point2I(box.point.x, box.point.y+size.y-handleSize.y);
|
|
drawUtil->drawRectFill(handleRect, handleColor); // Lower left
|
|
handleRect.point = Point2I(box.point.x+size.x-handleSize.x, box.point.y+size.y-handleSize.y);
|
|
drawUtil->drawRectFill(handleRect, handleColor); // Lower right
|
|
|
|
Point2I halfSize = size / 2;
|
|
Point2I halfHandleSize = handleSize / 2;
|
|
handleRect.point = Point2I(box.point.x+halfSize.x-halfHandleSize.x, box.point.y);
|
|
drawUtil->drawRectFill(handleRect, handleColor); // Upper middle
|
|
handleRect.point = Point2I(box.point.x+halfSize.x-halfHandleSize.x, box.point.y+size.y-handleSize.y);
|
|
drawUtil->drawRectFill(handleRect, handleColor); // Lower middle
|
|
handleRect.point = Point2I(box.point.x, box.point.y+halfSize.y-halfHandleSize.y);
|
|
drawUtil->drawRectFill(handleRect, handleColor); // Left middle
|
|
handleRect.point = Point2I(box.point.x+size.x-handleSize.x, box.point.y+halfSize.y-halfHandleSize.y);
|
|
drawUtil->drawRectFill(handleRect, handleColor); // Right middle
|
|
|
|
handleRect.point = Point2I(box.point.x+halfSize.x-halfHandleSize.x, box.point.y+halfSize.y-halfHandleSize.y);
|
|
drawUtil->drawRectFill(handleRect, handleColor); // Middle
|
|
|
|
renderChildControls(offset, updateRect);
|
|
}
|