mirror of
https://github.com/Gigaslav/HL2Overcharged.git
synced 2025-12-31 05:48:28 +03:00
956 lines
23 KiB
C++
956 lines
23 KiB
C++
//========= Copyright Valve Corporation, All rights reserved. ============//
|
|
//
|
|
// Purpose:
|
|
//
|
|
// $NoKeywords: $
|
|
//=============================================================================//
|
|
|
|
#include "cbase.h"
|
|
#include <stdio.h>
|
|
#define PROTECTED_THINGS_DISABLE
|
|
|
|
#include <vgui/MouseCode.h>
|
|
#include <KeyValues.h>
|
|
#include <vgui/IBorder.h>
|
|
#include <vgui/IInput.h>
|
|
#include <vgui/ISystem.h>
|
|
#include <vgui/IScheme.h>
|
|
#include <vgui/ISurface.h>
|
|
#include <vgui/ILocalize.h>
|
|
|
|
#include "game_controls/FloatSlider.h"
|
|
#include <vgui_controls/Controls.h>
|
|
#include <vgui_controls/TextImage.h>
|
|
|
|
// memdbgon must be the last include file in a .cpp file!!!
|
|
#include <tier0/memdbgon.h>
|
|
|
|
using namespace vgui;
|
|
|
|
DECLARE_BUILD_FACTORY(FloatSlider);
|
|
|
|
static const float NOB_SIZE = 8.0f;
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose: Create a slider bar with ticks underneath it
|
|
//-----------------------------------------------------------------------------
|
|
FloatSlider::FloatSlider(Panel *parent, const char *panelName) : BaseClass(parent, panelName)
|
|
{
|
|
m_bIsDragOnRepositionNob = false;
|
|
_dragging = false;
|
|
_value = 0;
|
|
_range[0] = 0;
|
|
_range[1] = 0;
|
|
_buttonOffset = 0;
|
|
_sliderBorder = NULL;
|
|
_insetBorder = NULL;
|
|
m_nNumTicks = 10;
|
|
_leftCaption = NULL;
|
|
_rightCaption = NULL;
|
|
|
|
_subrange[0] = 0;
|
|
_subrange[1] = 0;
|
|
m_bUseSubRange = false;
|
|
m_bInverted = false;
|
|
|
|
SetThumbWidth(8);
|
|
RecomputeNobPosFromValue();
|
|
AddActionSignalTarget(this);
|
|
SetBlockDragChaining(true);
|
|
}
|
|
|
|
// This allows the slider to behave like it's larger than what's actually being drawn
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose:
|
|
// Input : bEnable -
|
|
// 0 -
|
|
// 100 -
|
|
//-----------------------------------------------------------------------------
|
|
void FloatSlider::SetSliderThumbSubRange(bool bEnable, int nMin /*= 0*/, int nMax /*= 100*/)
|
|
{
|
|
m_bUseSubRange = bEnable;
|
|
_subrange[0] = nMin;
|
|
_subrange[1] = nMax;
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose: Set the size of the slider bar.
|
|
// Warning less than 30 pixels tall and everything probably won't fit.
|
|
//-----------------------------------------------------------------------------
|
|
void FloatSlider::OnSizeChanged(int wide, int tall)
|
|
{
|
|
BaseClass::OnSizeChanged(wide, tall);
|
|
|
|
RecomputeNobPosFromValue();
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose: Set the value of the slider to one of the ticks.
|
|
//-----------------------------------------------------------------------------
|
|
void FloatSlider::SetValue(float value, bool bTriggerChangeMessage)
|
|
{
|
|
float oldValue = _value;
|
|
|
|
if (_range[0] < _range[1])
|
|
{
|
|
if (value<_range[0])
|
|
{
|
|
value = _range[0];
|
|
}
|
|
if (value>_range[1])
|
|
{
|
|
value = _range[1];
|
|
}
|
|
}
|
|
else
|
|
{
|
|
if (value<_range[1])
|
|
{
|
|
value = _range[1];
|
|
}
|
|
if (value>_range[0])
|
|
{
|
|
value = _range[0];
|
|
}
|
|
}
|
|
|
|
_value = value;
|
|
|
|
RecomputeNobPosFromValue();
|
|
|
|
if (_value != oldValue && bTriggerChangeMessage)
|
|
{
|
|
SendSliderMovedMessage();
|
|
}
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose: Return the value of the slider
|
|
//-----------------------------------------------------------------------------
|
|
float FloatSlider::GetValue()
|
|
{
|
|
return _value;
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose: Layout the slider before drawing it on screen.
|
|
//-----------------------------------------------------------------------------
|
|
void FloatSlider::PerformLayout()
|
|
{
|
|
BaseClass::PerformLayout();
|
|
RecomputeNobPosFromValue();
|
|
|
|
if (_leftCaption)
|
|
{
|
|
_leftCaption->ResizeImageToContent();
|
|
}
|
|
if (_rightCaption)
|
|
{
|
|
_rightCaption->ResizeImageToContent();
|
|
}
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose: Move the nob on the slider in response to changing its value.
|
|
//-----------------------------------------------------------------------------
|
|
void FloatSlider::RecomputeNobPosFromValue()
|
|
{
|
|
//int wide,tall;
|
|
//GetPaintSize(wide,tall);
|
|
int x, y, wide, tall;
|
|
GetTrackRect(x, y, wide, tall);
|
|
|
|
float usevalue = _value;
|
|
float *userange = &_range[0];
|
|
if (m_bUseSubRange)
|
|
{
|
|
userange = &_subrange[0];
|
|
usevalue = clamp(_value, _subrange[0], _subrange[1]);
|
|
}
|
|
|
|
float fwide = (float)wide;
|
|
float frange = (float)(userange[1] - userange[0]);
|
|
float fvalue = (float)(usevalue - userange[0]);
|
|
float fper = (frange != 0.0f) ? fvalue / frange : 0.0f;
|
|
|
|
if (m_bInverted)
|
|
fper = 1.0f - fper;
|
|
|
|
float freepixels = fwide - _nobSize;
|
|
float leftpixel = (float)x;
|
|
float firstpixel = leftpixel + freepixels * fper + 0.5f;
|
|
|
|
_nobPos[0] = (int)(firstpixel);
|
|
_nobPos[1] = (int)(firstpixel + _nobSize);
|
|
|
|
|
|
int rightEdge = x + wide;
|
|
|
|
if (_nobPos[1]> rightEdge)
|
|
{
|
|
_nobPos[0] = rightEdge - _nobSize;
|
|
_nobPos[1] = rightEdge;
|
|
}
|
|
|
|
Repaint();
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose: Sync the slider's value up with the nob's position.
|
|
//-----------------------------------------------------------------------------
|
|
void FloatSlider::RecomputeValueFromNobPos()
|
|
{
|
|
float value = EstimateValueAtPos(_nobPos[0], 0);
|
|
SetValue(value);
|
|
}
|
|
|
|
float FloatSlider::EstimateValueAtPos(int localMouseX, int /*localMouseY*/)
|
|
{
|
|
int x, y, wide, tall;
|
|
GetTrackRect(x, y, wide, tall);
|
|
|
|
float *userange = &_range[0];
|
|
if (m_bUseSubRange)
|
|
{
|
|
userange = &_subrange[0];
|
|
}
|
|
|
|
float fwide = (float)wide;
|
|
float fvalue = (float)(_value - userange[0]);
|
|
float fnob = (float)(localMouseX - x);
|
|
float freepixels = fwide - _nobSize;
|
|
|
|
// Map into reduced range
|
|
fvalue = freepixels != 0.0f ? fnob / freepixels : 0.0f;
|
|
|
|
return RemapVal(fvalue, 0.0, 1.0, userange[0], userange[1]);
|
|
}
|
|
|
|
void FloatSlider::SetInverted(bool bInverted)
|
|
{
|
|
m_bInverted = bInverted;
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose: Send a message to interested parties when the slider moves
|
|
//-----------------------------------------------------------------------------
|
|
void FloatSlider::SendSliderMovedMessage()
|
|
{
|
|
// send a changed message
|
|
KeyValues *pParams = new KeyValues("SliderMoved", "position", _value);
|
|
pParams->SetPtr("panel", this);
|
|
PostActionSignal(pParams);
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose: Send a message to interested parties when the user begins dragging the slider
|
|
//-----------------------------------------------------------------------------
|
|
void FloatSlider::SendSliderDragStartMessage()
|
|
{
|
|
// send a message
|
|
KeyValues *pParams = new KeyValues("SliderDragStart", "position", _value);
|
|
pParams->SetPtr("panel", this);
|
|
PostActionSignal(pParams);
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose: Send a message to interested parties when the user ends dragging the slider
|
|
//-----------------------------------------------------------------------------
|
|
void FloatSlider::SendSliderDragEndMessage()
|
|
{
|
|
// send a message
|
|
KeyValues *pParams = new KeyValues("SliderDragEnd", "position", _value);
|
|
pParams->SetPtr("panel", this);
|
|
PostActionSignal(pParams);
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose:
|
|
//-----------------------------------------------------------------------------
|
|
void FloatSlider::ApplySchemeSettings(IScheme *pScheme)
|
|
{
|
|
BaseClass::ApplySchemeSettings(pScheme);
|
|
|
|
SetFgColor(GetSchemeColor("FloatSlider.NobColor", pScheme));
|
|
// this line is useful for debugging
|
|
//SetBgColor(GetSchemeColor("0 0 0 255"));
|
|
|
|
m_TickColor = pScheme->GetColor("FloatSlider.TextColor", GetFgColor());
|
|
m_TrackColor = pScheme->GetColor("FloatSlider.TrackColor", GetFgColor());
|
|
|
|
#ifdef _X360
|
|
m_DepressedBgColor = GetSchemeColor("FloatSlider.NobFocusColor", pScheme);
|
|
#endif
|
|
|
|
m_DisabledTextColor1 = pScheme->GetColor("FloatSlider.DisabledTextColor1", GetFgColor());
|
|
m_DisabledTextColor2 = pScheme->GetColor("FloatSlider.DisabledTextColor2", GetFgColor());
|
|
|
|
_sliderBorder = pScheme->GetBorder("ButtonBorder");
|
|
_insetBorder = pScheme->GetBorder("ButtonDepressedBorder");
|
|
|
|
if (_leftCaption)
|
|
{
|
|
_leftCaption->SetFont(pScheme->GetFont("DefaultVerySmall", IsProportional()));
|
|
}
|
|
|
|
if (_rightCaption)
|
|
{
|
|
_rightCaption->SetFont(pScheme->GetFont("DefaultVerySmall", IsProportional()));
|
|
}
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose:
|
|
//-----------------------------------------------------------------------------
|
|
void FloatSlider::GetSettings(KeyValues *outResourceData)
|
|
{
|
|
BaseClass::GetSettings(outResourceData);
|
|
|
|
char buf[256];
|
|
if (_leftCaption)
|
|
{
|
|
_leftCaption->GetUnlocalizedText(buf, sizeof(buf));
|
|
outResourceData->SetString("leftText", buf);
|
|
}
|
|
|
|
if (_rightCaption)
|
|
{
|
|
_rightCaption->GetUnlocalizedText(buf, sizeof(buf));
|
|
outResourceData->SetString("rightText", buf);
|
|
}
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose:
|
|
//-----------------------------------------------------------------------------
|
|
void FloatSlider::ApplySettings(KeyValues *inResourceData)
|
|
{
|
|
BaseClass::ApplySettings(inResourceData);
|
|
|
|
const char *left = inResourceData->GetString("leftText", NULL);
|
|
const char *right = inResourceData->GetString("rightText", NULL);
|
|
|
|
int thumbWidth = inResourceData->GetInt("thumbwidth", 0);
|
|
if (thumbWidth != 0)
|
|
{
|
|
SetThumbWidth(thumbWidth);
|
|
}
|
|
|
|
SetTickCaptions(left, right);
|
|
|
|
int nNumTicks = inResourceData->GetInt("numTicks", -1);
|
|
if (nNumTicks >= 0)
|
|
{
|
|
SetNumTicks(nNumTicks);
|
|
}
|
|
|
|
float nCurrentRange[2];
|
|
GetRange(nCurrentRange[0], nCurrentRange[1]);
|
|
KeyValues *pRangeMin = inResourceData->FindKey("rangeMin", false);
|
|
KeyValues *pRangeMax = inResourceData->FindKey("rangeMax", false);
|
|
bool bDoClamp = false;
|
|
if (pRangeMin)
|
|
{
|
|
_range[0] = inResourceData->GetFloat("rangeMin");
|
|
bDoClamp = true;
|
|
}
|
|
if (pRangeMax)
|
|
{
|
|
_range[1] = inResourceData->GetFloat("rangeMax");
|
|
bDoClamp = true;
|
|
}
|
|
|
|
if (bDoClamp)
|
|
{
|
|
ClampRange();
|
|
}
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose:
|
|
//-----------------------------------------------------------------------------
|
|
const char *FloatSlider::GetDescription()
|
|
{
|
|
static char buf[1024];
|
|
Q_snprintf(buf, sizeof(buf), "%s, string leftText, string rightText", BaseClass::GetDescription());
|
|
return buf;
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose: Get the rectangle to draw the slider track in.
|
|
//-----------------------------------------------------------------------------
|
|
void FloatSlider::GetTrackRect(int& x, int& y, int& w, int& h)
|
|
{
|
|
int wide, tall;
|
|
GetPaintSize(wide, tall);
|
|
|
|
x = 0;
|
|
y = 8;
|
|
w = wide - (int)_nobSize;
|
|
h = 4;
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose: Draw everything on screen
|
|
//-----------------------------------------------------------------------------
|
|
void FloatSlider::Paint()
|
|
{
|
|
DrawTicks();
|
|
|
|
DrawTickLabels();
|
|
|
|
// Draw nob last so it draws over ticks.
|
|
DrawNob();
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose: Draw the ticks below the slider.
|
|
//-----------------------------------------------------------------------------
|
|
void FloatSlider::DrawTicks()
|
|
{
|
|
int x, y;
|
|
int wide, tall;
|
|
GetTrackRect(x, y, wide, tall);
|
|
|
|
// Figure out how to draw the ticks
|
|
// GetPaintSize( wide, tall );
|
|
|
|
float fwide = (float)wide;
|
|
float freepixels = fwide - _nobSize;
|
|
|
|
float leftpixel = _nobSize / 2.0f;
|
|
|
|
float pixelspertick = freepixels / (m_nNumTicks);
|
|
|
|
y += (int)_nobSize;
|
|
int tickHeight = 5;
|
|
|
|
if (IsEnabled())
|
|
{
|
|
surface()->DrawSetColor(m_TickColor); //vgui::Color( 127, 140, 127, 255 ) );
|
|
for (int i = 0; i <= m_nNumTicks; i++)
|
|
{
|
|
int xpos = (int)(leftpixel + i * pixelspertick);
|
|
|
|
surface()->DrawFilledRect(xpos, y, xpos + 1, y + tickHeight);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
surface()->DrawSetColor(m_DisabledTextColor1); //vgui::Color( 127, 140, 127, 255 ) );
|
|
for (int i = 0; i <= m_nNumTicks; i++)
|
|
{
|
|
int xpos = (int)(leftpixel + i * pixelspertick);
|
|
surface()->DrawFilledRect(xpos + 1, y + 1, xpos + 2, y + tickHeight + 1);
|
|
}
|
|
surface()->DrawSetColor(m_DisabledTextColor2); //vgui::Color( 127, 140, 127, 255 ) );
|
|
for (int i = 0; i <= m_nNumTicks; i++)
|
|
{
|
|
int xpos = (int)(leftpixel + i * pixelspertick);
|
|
surface()->DrawFilledRect(xpos, y, xpos + 1, y + tickHeight);
|
|
}
|
|
}
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose: Draw Tick labels under the ticks.
|
|
//-----------------------------------------------------------------------------
|
|
void FloatSlider::DrawTickLabels()
|
|
{
|
|
int x, y;
|
|
int wide, tall;
|
|
GetTrackRect(x, y, wide, tall);
|
|
|
|
// Figure out how to draw the ticks
|
|
// GetPaintSize( wide, tall );
|
|
y += (int)NOB_SIZE + 4;
|
|
|
|
// Draw Start and end range values
|
|
if (IsEnabled())
|
|
surface()->DrawSetTextColor(m_TickColor); //vgui::Color( 127, 140, 127, 255 ) );
|
|
else
|
|
surface()->DrawSetTextColor(m_DisabledTextColor1); //vgui::Color( 127, 140, 127, 255 ) );
|
|
|
|
|
|
if (_leftCaption != NULL)
|
|
{
|
|
_leftCaption->SetPos(0, y);
|
|
if (IsEnabled())
|
|
{
|
|
_leftCaption->SetColor(m_TickColor);
|
|
}
|
|
else
|
|
{
|
|
_leftCaption->SetColor(m_DisabledTextColor1);
|
|
}
|
|
|
|
_leftCaption->Paint();
|
|
}
|
|
|
|
if (_rightCaption != NULL)
|
|
{
|
|
int rwide, rtall;
|
|
_rightCaption->GetSize(rwide, rtall);
|
|
_rightCaption->SetPos((int)(wide - rwide), y);
|
|
if (IsEnabled())
|
|
{
|
|
_rightCaption->SetColor(m_TickColor);
|
|
}
|
|
else
|
|
{
|
|
_rightCaption->SetColor(m_DisabledTextColor1);
|
|
}
|
|
|
|
_rightCaption->Paint();
|
|
}
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose: Draw the nob part of the slider.
|
|
//-----------------------------------------------------------------------------
|
|
void FloatSlider::DrawNob()
|
|
{
|
|
// horizontal nob
|
|
int x, y;
|
|
int wide, tall;
|
|
GetTrackRect(x, y, wide, tall);
|
|
Color col = GetFgColor();
|
|
#ifdef _X360
|
|
if (HasFocus())
|
|
{
|
|
col = m_DepressedBgColor;
|
|
}
|
|
#endif
|
|
surface()->DrawSetColor(col);
|
|
|
|
int nobheight = 16;
|
|
|
|
surface()->DrawFilledRect(
|
|
_nobPos[0],
|
|
y + tall / 2 - nobheight / 2,
|
|
_nobPos[1],
|
|
y + tall / 2 + nobheight / 2);
|
|
// border
|
|
if (_sliderBorder)
|
|
{
|
|
_sliderBorder->Paint(
|
|
_nobPos[0],
|
|
y + tall / 2 - nobheight / 2,
|
|
_nobPos[1],
|
|
y + tall / 2 + nobheight / 2);
|
|
}
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose: Set the text labels of the Start and end ticks.
|
|
//-----------------------------------------------------------------------------
|
|
void FloatSlider::SetTickCaptions(const char *left, const char *right)
|
|
{
|
|
if (left)
|
|
{
|
|
if (_leftCaption)
|
|
{
|
|
_leftCaption->SetText(left);
|
|
}
|
|
else
|
|
{
|
|
_leftCaption = new TextImage(left);
|
|
}
|
|
}
|
|
if (right)
|
|
{
|
|
if (_rightCaption)
|
|
{
|
|
_rightCaption->SetText(right);
|
|
}
|
|
else
|
|
{
|
|
_rightCaption = new TextImage(right);
|
|
}
|
|
}
|
|
InvalidateLayout();
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose: Set the text labels of the Start and end ticks.
|
|
//-----------------------------------------------------------------------------
|
|
void FloatSlider::SetTickCaptions(const wchar_t *left, const wchar_t *right)
|
|
{
|
|
if (left)
|
|
{
|
|
if (_leftCaption)
|
|
{
|
|
_leftCaption->SetText(left);
|
|
}
|
|
else
|
|
{
|
|
_leftCaption = new TextImage(left);
|
|
}
|
|
}
|
|
if (right)
|
|
{
|
|
if (_rightCaption)
|
|
{
|
|
_rightCaption->SetText(right);
|
|
}
|
|
else
|
|
{
|
|
_rightCaption = new TextImage(right);
|
|
}
|
|
}
|
|
InvalidateLayout();
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose: Draw the slider track
|
|
//-----------------------------------------------------------------------------
|
|
void FloatSlider::PaintBackground()
|
|
{
|
|
BaseClass::PaintBackground();
|
|
|
|
int x, y;
|
|
int wide, tall;
|
|
|
|
GetTrackRect(x, y, wide, tall);
|
|
|
|
surface()->DrawSetColor(m_TrackColor);
|
|
surface()->DrawFilledRect(x, y, x + wide, y + tall);
|
|
if (_insetBorder)
|
|
{
|
|
_insetBorder->Paint(x, y, x + wide, y + tall);
|
|
}
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose: Set the range of the slider.
|
|
//-----------------------------------------------------------------------------
|
|
void FloatSlider::SetRange(float min, float max)
|
|
{
|
|
_range[0] = min;
|
|
_range[1] = max;
|
|
|
|
ClampRange();
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose: Sanity check and clamp the range if necessary.
|
|
//-----------------------------------------------------------------------------
|
|
void FloatSlider::ClampRange()
|
|
{
|
|
if (_range[0] < _range[1])
|
|
{
|
|
if (_value<_range[0])
|
|
{
|
|
SetValue(_range[0], false);
|
|
}
|
|
else if (_value>_range[1])
|
|
{
|
|
SetValue(_range[1], false);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
if (_value<_range[1])
|
|
{
|
|
SetValue(_range[1], false);
|
|
}
|
|
else if (_value>_range[0])
|
|
{
|
|
SetValue(_range[0], false);
|
|
}
|
|
}
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose: Get the max and min values of the slider
|
|
//-----------------------------------------------------------------------------
|
|
void FloatSlider::GetRange(float& min, float& max)
|
|
{
|
|
min = _range[0];
|
|
max = _range[1];
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose: Respond when the cursor is moved in our window if we are clicking
|
|
// and dragging.
|
|
//-----------------------------------------------------------------------------
|
|
void FloatSlider::OnCursorMoved(int x, int y)
|
|
{
|
|
if (!_dragging)
|
|
{
|
|
return;
|
|
}
|
|
|
|
// input()->GetCursorPos(x,y);
|
|
input()->GetCursorPosition(x, y);
|
|
ScreenToLocal(x, y);
|
|
|
|
// int wide,tall;
|
|
// GetPaintSize(wide,tall);
|
|
int _x, _y, wide, tall;
|
|
GetTrackRect(_x, _y, wide, tall);
|
|
|
|
_nobPos[0] = _nobDragStartPos[0] + (x - _dragStartPos[0]);
|
|
_nobPos[1] = _nobDragStartPos[1] + (x - _dragStartPos[0]);
|
|
|
|
int rightEdge = _x + wide;
|
|
int unclamped = _nobPos[0];
|
|
|
|
if (_nobPos[1]>rightEdge)
|
|
{
|
|
_nobPos[0] = rightEdge - (_nobPos[1] - _nobPos[0]);
|
|
_nobPos[1] = rightEdge;
|
|
}
|
|
|
|
if (_nobPos[0]<_x)
|
|
{
|
|
int offset = _x - _nobPos[0];
|
|
_nobPos[1] = _nobPos[1] - offset;
|
|
_nobPos[0] = 0;
|
|
}
|
|
|
|
int value = EstimateValueAtPos(unclamped, 0);
|
|
SetValue(value);
|
|
|
|
// RecomputeValueFromNobPos();
|
|
Repaint();
|
|
SendSliderMovedMessage();
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose: If you click on the slider outside of the nob, the nob jumps
|
|
// to the click position, and if this setting is enabled, the nob
|
|
// is then draggable from the new position until the mouse is released
|
|
// Input : state -
|
|
//-----------------------------------------------------------------------------
|
|
void FloatSlider::SetDragOnRepositionNob(bool state)
|
|
{
|
|
m_bIsDragOnRepositionNob = state;
|
|
}
|
|
|
|
bool FloatSlider::IsDragOnRepositionNob() const
|
|
{
|
|
return m_bIsDragOnRepositionNob;
|
|
}
|
|
|
|
bool FloatSlider::IsDragged(void) const
|
|
{
|
|
return _dragging;
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose: Respond to mouse presses. Trigger Record staring positon.
|
|
//-----------------------------------------------------------------------------
|
|
void FloatSlider::OnMousePressed(MouseCode code)
|
|
{
|
|
int x, y;
|
|
|
|
if (!IsEnabled())
|
|
return;
|
|
|
|
// input()->GetCursorPos(x,y);
|
|
input()->GetCursorPosition(x, y);
|
|
|
|
ScreenToLocal(x, y);
|
|
RequestFocus();
|
|
|
|
bool startdragging = false, bPostDragStartSignal = false;
|
|
|
|
if ((x >= _nobPos[0]) && (x < _nobPos[1]))
|
|
{
|
|
startdragging = true;
|
|
bPostDragStartSignal = true;
|
|
}
|
|
else
|
|
{
|
|
// we clicked elsewhere on the slider; move the nob to that position
|
|
float min, max;
|
|
GetRange(min, max);
|
|
if (m_bUseSubRange)
|
|
{
|
|
min = _subrange[0];
|
|
max = _subrange[1];
|
|
}
|
|
|
|
// int wide = GetWide();
|
|
int _x, _y, wide, tall;
|
|
GetTrackRect(_x, _y, wide, tall);
|
|
if (wide > 0)
|
|
{
|
|
float frange = (float)(max - min);
|
|
float clickFrac = clamp((float)(x - _x) / (float)(wide - 1), 0.0f, 1.0f);
|
|
|
|
float value = (float)min + clickFrac * frange;
|
|
|
|
startdragging = IsDragOnRepositionNob();
|
|
|
|
if (startdragging)
|
|
{
|
|
_dragging = true; // Required when as
|
|
SendSliderDragStartMessage();
|
|
}
|
|
|
|
SetValue(value);
|
|
}
|
|
}
|
|
|
|
if (startdragging)
|
|
{
|
|
// drag the nob
|
|
_dragging = true;
|
|
input()->SetMouseCapture(GetVPanel());
|
|
_nobDragStartPos[0] = _nobPos[0];
|
|
_nobDragStartPos[1] = _nobPos[1];
|
|
_dragStartPos[0] = x;
|
|
_dragStartPos[1] = y;
|
|
}
|
|
|
|
if (bPostDragStartSignal)
|
|
SendSliderDragStartMessage();
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose: Just handle double presses like mouse presses
|
|
//-----------------------------------------------------------------------------
|
|
void FloatSlider::OnMouseDoublePressed(MouseCode code)
|
|
{
|
|
OnMousePressed(code);
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose:
|
|
//-----------------------------------------------------------------------------
|
|
#ifdef _X360
|
|
void FloatSlider::OnKeyCodePressed(KeyCode code)
|
|
{
|
|
switch (GetBaseButtonCode(code))
|
|
{
|
|
case KEY_XBUTTON_LEFT:
|
|
case KEY_XSTICK1_LEFT:
|
|
case KEY_XSTICK2_LEFT:
|
|
SetValue(GetValue() - 1);
|
|
break;
|
|
case KEY_XBUTTON_RIGHT:
|
|
case KEY_XSTICK1_RIGHT:
|
|
case KEY_XSTICK2_RIGHT:
|
|
SetValue(GetValue() + 1);
|
|
break;
|
|
default:
|
|
BaseClass::OnKeyCodePressed(code);
|
|
break;
|
|
}
|
|
}
|
|
#endif
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose: Handle key presses
|
|
//-----------------------------------------------------------------------------
|
|
void FloatSlider::OnKeyCodeTyped(KeyCode code)
|
|
{
|
|
switch (code)
|
|
{
|
|
// for now left and right arrows just open or close submenus if they are there.
|
|
case KEY_LEFT:
|
|
case KEY_DOWN:
|
|
{
|
|
float val = GetValue();
|
|
SetValue(val - 0.1f);
|
|
break;
|
|
}
|
|
case KEY_RIGHT:
|
|
case KEY_UP:
|
|
{
|
|
int val = GetValue();
|
|
SetValue(val + 0.1f);
|
|
break;
|
|
}
|
|
case KEY_PAGEDOWN:
|
|
{
|
|
float min, max;
|
|
GetRange(min, max);
|
|
float range = max - min;
|
|
float pertick = range / m_nNumTicks;
|
|
float val = GetValue();
|
|
SetValue(val - pertick);
|
|
break;
|
|
}
|
|
case KEY_PAGEUP:
|
|
{
|
|
float min, max;
|
|
GetRange(min, max);
|
|
float range = max - min;
|
|
float pertick = range / m_nNumTicks;
|
|
float val = GetValue();
|
|
SetValue(val + pertick);
|
|
break;
|
|
}
|
|
case KEY_HOME:
|
|
{
|
|
float min, max;
|
|
GetRange(min, max);
|
|
SetValue(min);
|
|
break;
|
|
}
|
|
case KEY_END:
|
|
{
|
|
float min, max;
|
|
GetRange(min, max);
|
|
SetValue(max);
|
|
break;
|
|
}
|
|
default:
|
|
BaseClass::OnKeyCodeTyped(code);
|
|
break;
|
|
}
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose: Stop dragging when the mouse is released.
|
|
//-----------------------------------------------------------------------------
|
|
void FloatSlider::OnMouseReleased(MouseCode code)
|
|
{
|
|
if (_dragging)
|
|
{
|
|
_dragging = false;
|
|
input()->SetMouseCapture(null);
|
|
}
|
|
|
|
if (IsEnabled())
|
|
{
|
|
SendSliderDragEndMessage();
|
|
}
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose: Get the nob's position (the ends of each side of the nob)
|
|
//-----------------------------------------------------------------------------
|
|
void FloatSlider::GetNobPos(float& min, float& max)
|
|
{
|
|
min = _nobPos[0];
|
|
max = _nobPos[1];
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose:
|
|
//-----------------------------------------------------------------------------
|
|
void FloatSlider::SetButtonOffset(int buttonOffset)
|
|
{
|
|
_buttonOffset = buttonOffset;
|
|
}
|
|
|
|
void FloatSlider::SetThumbWidth(int width)
|
|
{
|
|
_nobSize = (float)width;
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose: Set the number of ticks that appear under the slider.
|
|
//-----------------------------------------------------------------------------
|
|
void FloatSlider::SetNumTicks(int ticks)
|
|
{
|
|
m_nNumTicks = ticks;
|
|
}
|