d4708
/
source-engine
mirror of https://github.com/nillerusr/source-engine.git
1
0
Fork 0
Code Issues Projects Releases Wiki Activity
Modified source engine (2017) developed by valve and leaked in 2020. Not for commercial purporses
You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
109 Commits
25 Branches
6 Tags
221 MiB
 
 
 
 
 
 
Tree: 9d77bb17c5
Branches Tags
${ item.name }
Create tag ${ searchTerm }
Create branch ${ searchTerm }
from '9d77bb17c5'
${ noResults }
source-engine/vgui2/matsys_controls/colorpickerpanel.cpp

1255 lines
35 KiB
Raw Blame History

//========= Copyright Valve Corporation, All rights reserved. ============//
//
// Purpose:
//
//===========================================================================//
#include "matsys_controls/colorpickerpanel.h"
#include "matsys_controls/matsyscontrols.h"
#include "matsys_controls/proceduraltexturepanel.h"
#include "materialsystem/imaterialsystem.h"
#include "materialsystem/itexture.h"
#include "pixelwriter.h"
#include "VGuiMatSurface/IMatSystemSurface.h"
#include "vgui_controls/Button.h"
#include "vgui_controls/TextEntry.h"
#include "vgui_controls/RadioButton.h"
#include "vgui/IInput.h"
#include "tier1/KeyValues.h"
#include "bitmap/imageformat.h"
using namespace vgui;
//-----------------------------------------------------------------------------
// Color picker
//-----------------------------------------------------------------------------
enum ColorType_t
{
COLOR_TYPE_RGB = 0,
COLOR_TYPE_HSV,
};
enum ColorChannel_t
{
CHANNEL_RED = 0,
CHANNEL_GREEN,
CHANNEL_BLUE,
CHANNEL_HUE = 0,
CHANNEL_SATURATION,
CHANNEL_VALUE,
};
//-----------------------------------------------------------------------------
// Converts RGB to normalized
//-----------------------------------------------------------------------------
static void RGB888ToVector( RGB888_t inColor, Vector *pOutVector )
{
pOutVector->Init( inColor.r / 255.0f, inColor.g / 255.0f, inColor.b / 255.0f );
}
static void VectorToRGB888( const Vector &inVector, RGB888_t &outColor )
{
int r = (int)((inVector.x * 255.0f) + 0.5f);
int g = (int)((inVector.y * 255.0f) + 0.5f);
int b = (int)((inVector.z * 255.0f) + 0.5f);
outColor.r = clamp( r, 0, 255 );
outColor.g = clamp( g, 0, 255 );
outColor.b = clamp( b, 0, 255 );
}
//-----------------------------------------------------------------------------
// Convert RGB to HSV
//-----------------------------------------------------------------------------
static inline void RGBtoHSV( const RGB888_t &rgb, Vector &hsv )
{
Vector vecRGB;
RGB888ToVector( rgb, &vecRGB );
RGBtoHSV( vecRGB, hsv );
}
//-----------------------------------------------------------------------------
// Convert HSV to RGB
//-----------------------------------------------------------------------------
static inline void HSVtoRGB( const Vector &hsv, RGB888_t &rgb )
{
Vector vecRGB;
HSVtoRGB( hsv, vecRGB );
VectorToRGB888( vecRGB, rgb );
}
//-----------------------------------------------------------------------------
// This previews the 'xy' color
//-----------------------------------------------------------------------------
class CColorXYPreview : public CProceduralTexturePanel
{
DECLARE_CLASS_SIMPLE( CColorXYPreview, CProceduralTexturePanel );
public:
// constructor
CColorXYPreview( vgui::Panel *pParent, const char *pName );
virtual void RegenerateTextureBits( ITexture *pTexture, IVTFTexture *pVTFTexture, Rect_t *pRect );
virtual void Paint( void );
virtual void OnMousePressed( vgui::MouseCode code );
virtual void OnMouseReleased( vgui::MouseCode code );
virtual void OnCursorMoved( int x, int y );
void SetMode( ColorType_t type, ColorChannel_t channel );
void SetColor( const RGB888_t &color, const Vector &hsvColor );
private:
// Computes a color given a particular x,y value
void ComputeColorForPoint( int x, int y, RGB888_t &color );
void ComputeHSVColorForPoint( int x, int y, Vector &vscHSV );
// Updates the color based on the mouse position
void UpdateColorFromMouse( int x, int y );
static ColorChannel_t s_pHSVRemapX[3];
static ColorChannel_t s_pHSVRemapY[3];
static ColorChannel_t s_pRGBRemapX[3];
static ColorChannel_t s_pRGBRemapY[3];
ColorType_t m_Type;
ColorChannel_t m_Channel;
RGB888_t m_CurrentColor;
Vector m_CurrentHSVColor;
vgui::HCursor m_hPickerCursor;
bool m_bDraggingMouse;
};
ColorChannel_t CColorXYPreview::s_pHSVRemapX[3] =
{
CHANNEL_SATURATION, CHANNEL_HUE, CHANNEL_HUE
};
ColorChannel_t CColorXYPreview::s_pHSVRemapY[3] =
{
CHANNEL_VALUE, CHANNEL_VALUE, CHANNEL_SATURATION
};
ColorChannel_t CColorXYPreview::s_pRGBRemapX[3] =
{
CHANNEL_BLUE, CHANNEL_BLUE, CHANNEL_RED
};
ColorChannel_t CColorXYPreview::s_pRGBRemapY[3] =
{
CHANNEL_GREEN, CHANNEL_RED, CHANNEL_GREEN
};
//-----------------------------------------------------------------------------
// Constructor
//-----------------------------------------------------------------------------
CColorXYPreview::CColorXYPreview( vgui::Panel *pParent, const char *pName ) : BaseClass( pParent, pName )
{
Init( 256, 256, false );
m_CurrentColor.r = m_CurrentColor.g = m_CurrentColor.b = 255;
SetMode( COLOR_TYPE_HSV, CHANNEL_HUE );
SetMouseInputEnabled( true );
m_hPickerCursor = surface()->CreateCursorFromFile( "resource/colorpicker.cur" );
SetCursor( m_hPickerCursor );
m_bDraggingMouse = false;
}
//-----------------------------------------------------------------------------
// Sets the mode for the preview
//-----------------------------------------------------------------------------
void CColorXYPreview::SetMode( ColorType_t type, ColorChannel_t channel )
{
if ( m_Type != type || m_Channel != channel )
{
m_Type = type;
m_Channel = channel;
DownloadTexture();
}
}
void CColorXYPreview::SetColor( const RGB888_t &color, const Vector &hsvColor )
{
if ( color != m_CurrentColor || m_CurrentHSVColor != hsvColor )
{
m_CurrentColor = color;
m_CurrentHSVColor = hsvColor;
DownloadTexture();
}
}
//-----------------------------------------------------------------------------
// Computes a color given a particular x,y value
//-----------------------------------------------------------------------------
void CColorXYPreview::ComputeColorForPoint( int x, int y, RGB888_t &color )
{
color = m_CurrentColor;
((unsigned char*)&color)[ s_pRGBRemapX[m_Channel] ] = x;
((unsigned char*)&color)[ s_pRGBRemapY[m_Channel] ] = GetImageHeight() - y - 1;
}
void CColorXYPreview::ComputeHSVColorForPoint( int x, int y, Vector &vscHSV )
{
vscHSV = m_CurrentHSVColor;
vscHSV[ s_pHSVRemapX[m_Channel] ] = (float)x / 255.0f;
vscHSV[ s_pHSVRemapY[m_Channel] ] = (float)(GetImageHeight() - y - 1) / 255.0f;
if ( vscHSV.y == 0.0f )
{
vscHSV.x = -1.0f;
}
if ( m_Channel != CHANNEL_HUE )
{
if ( vscHSV.x != -1.0f )
{
vscHSV.x *= 360.0f;
}
}
}
//-----------------------------------------------------------------------------
// Fills the texture w/ the image buffer
//-----------------------------------------------------------------------------
void CColorXYPreview::RegenerateTextureBits( ITexture *pTexture, IVTFTexture *pVTFTexture, Rect_t *pRect )
{
Assert( pVTFTexture->FrameCount() == 1 );
Assert( pVTFTexture->FaceCount() == 1 );
Assert( !pTexture->IsMipmapped() );
int nWidth, nHeight, nDepth;
pVTFTexture->ComputeMipLevelDimensions( 0, &nWidth, &nHeight, &nDepth );
Assert( nDepth == 1 );
Assert( nWidth == m_nWidth && nHeight == m_nHeight );
CPixelWriter pixelWriter;
pixelWriter.SetPixelMemory( pVTFTexture->Format(),
pVTFTexture->ImageData( 0, 0, 0 ), pVTFTexture->RowSizeInBytes( 0 ) );
for ( int y = 0; y < nHeight; ++y )
{
pixelWriter.Seek( 0, y );
for ( int x = 0; x < nWidth; ++x )
{
RGB888_t color;
if ( m_Type != COLOR_TYPE_RGB )
{
Vector vecHSV;
ComputeHSVColorForPoint( x, y, vecHSV );
HSVtoRGB( vecHSV, color );
}
else
{
ComputeColorForPoint( x, y, color );
}
pixelWriter.WritePixel( color.r, color.g, color.b, 255 );
}
}
}
//-----------------------------------------------------------------------------
// Paints a circle over the currently selected color
//-----------------------------------------------------------------------------
void CColorXYPreview::Paint( void )
{
BaseClass::Paint();
int x, y;
if ( m_Type != COLOR_TYPE_RGB )
{
Vector vecHSVNormalized = m_CurrentHSVColor;
if ( vecHSVNormalized.x != -1.0f )
{
vecHSVNormalized.x *= 255.0f / 360.0f;
}
vecHSVNormalized.y *= 255.0f;
vecHSVNormalized.z *= 255.0f;
x = (int)( vecHSVNormalized[ s_pHSVRemapX[m_Channel] ] + 0.5f);
y = GetImageHeight() - 1 - (int)( vecHSVNormalized[ s_pHSVRemapY[m_Channel] ] + 0.5f );
}
else
{
x = ((unsigned char*)&m_CurrentColor)[ s_pRGBRemapX[m_Channel] ];
y = GetImageHeight() - 1 - ((unsigned char*)&m_CurrentColor)[ s_pRGBRemapY[m_Channel] ];
}
// Renormalize x, y to actual size
int w, h;
GetSize( w, h );
x = (int)( w * (float)x / 255.0f + 0.5f );
y = (int)( h * (float)y / 255.0f + 0.5f );
vgui::surface()->DrawSetColor( 255, 255, 255, 255 );
vgui::surface()->DrawOutlinedCircle( x, y, 5, 8 );
vgui::surface()->DrawSetColor( 0, 0, 0, 255 );
vgui::surface()->DrawOutlinedCircle( x, y, 6, 8 );
}
//-----------------------------------------------------------------------------
// Updates the color based on the mouse position
//-----------------------------------------------------------------------------
void CColorXYPreview::UpdateColorFromMouse( int x, int y )
{
int w, h;
GetSize( w, h );
float flNormalizedX = (float)x / (w-1);
float flNormalizedY = (float)y / (h-1);
flNormalizedX = clamp( flNormalizedX, 0.0f, 1.0f );
flNormalizedY = clamp( flNormalizedY, 0.0f, 1.0f );
int tx = (int)( (GetImageWidth()-1) * flNormalizedX + 0.5f );
int ty = (int)( (GetImageHeight()-1) * flNormalizedY + 0.5f );
if ( m_Type != COLOR_TYPE_RGB )
{
Vector vecHSV;
ComputeHSVColorForPoint( tx, ty, vecHSV );
KeyValues *pKeyValues = new KeyValues( "HSVSelected" );
pKeyValues->SetFloat( "hue", vecHSV.x );
pKeyValues->SetFloat( "saturation", vecHSV.y );
pKeyValues->SetFloat( "value", vecHSV.z );
PostActionSignal( pKeyValues );
// This prevents a 1-frame lag in the current color position
RGB888_t color;
HSVtoRGB( vecHSV, color );
SetColor( color, vecHSV );
}
else
{
RGB888_t color;
ComputeColorForPoint( tx, ty, color );
Color c( color.r, color.g, color.b, 255 );
KeyValues *pKeyValues = new KeyValues( "ColorSelected" );
pKeyValues->SetColor( "color", c );
PostActionSignal( pKeyValues );
// This prevents a 1-frame lag in the current color position
Vector vecHSV;
RGBtoHSV( color, vecHSV );
SetColor( color, vecHSV );
}
}
//-----------------------------------------------------------------------------
// Handle input
//-----------------------------------------------------------------------------
void CColorXYPreview::OnMousePressed( vgui::MouseCode code )
{
BaseClass::OnMousePressed( code );
if ( code == MOUSE_LEFT )
{
if ( !m_bDraggingMouse )
{
m_bDraggingMouse = true;
input()->SetMouseCapture(GetVPanel());
int x, y;
input()->GetCursorPos( x, y );
ScreenToLocal( x, y );
UpdateColorFromMouse( x, y );
}
}
}
void CColorXYPreview::OnMouseReleased( vgui::MouseCode code )
{
BaseClass::OnMouseReleased( code );
if ( code == MOUSE_LEFT )
{
if ( m_bDraggingMouse )
{
m_bDraggingMouse = false;
input()->SetMouseCapture( (VPANEL)0 );
}
}
}
void CColorXYPreview::OnCursorMoved( int x, int y )
{
BaseClass::OnCursorMoved( x, y );
if ( m_bDraggingMouse )
{
UpdateColorFromMouse( x, y );
}
}
//-----------------------------------------------------------------------------
// This previews the 'z' color
//-----------------------------------------------------------------------------
class CColorZPreview : public CProceduralTexturePanel
{
DECLARE_CLASS_SIMPLE( CColorZPreview, CProceduralTexturePanel );
public:
// constructor
CColorZPreview( vgui::Panel *pParent, const char *pName );
virtual void RegenerateTextureBits( ITexture *pTexture, IVTFTexture *pVTFTexture, Rect_t *pRect );
virtual void PerformLayout();
virtual void Paint( void );
virtual void OnCursorMoved( int x,int y );
virtual void OnMousePressed( vgui::MouseCode code );
virtual void OnMouseReleased( vgui::MouseCode code );
void SetMode( ColorType_t type, ColorChannel_t channel );
void SetColor( const RGB888_t &color, const Vector &hsvColor );
// Computes a color given a particular x,y value
void ComputeColorForPoint( int y, RGB888_t &color );
void ComputeHSVColorForPoint( int y, bool bProceduralTexture, Vector &vecHSV );
private:
// Updates the color based on the mouse position
void UpdateColorFromMouse( int x, int y );
ColorType_t m_Type;
ColorChannel_t m_Channel;
RGB888_t m_CurrentColor;
Vector m_CurrentHSVColor;
bool m_bDraggingMouse;
};
#define MARKER_WIDTH 6
//-----------------------------------------------------------------------------
// Constructor
//-----------------------------------------------------------------------------
CColorZPreview::CColorZPreview( vgui::Panel *pParent, const char *pName ) : BaseClass( pParent, pName )
{
Init( 8, 256, false );
m_CurrentColor.r = m_CurrentColor.g = m_CurrentColor.b = 255;
Vector vecRGB;
RGB888ToVector( m_CurrentColor, &vecRGB );
RGBtoHSV( vecRGB, m_CurrentHSVColor );
m_bDraggingMouse = false;
SetMouseInputEnabled( true );
SetMode( COLOR_TYPE_HSV, CHANNEL_HUE );
}
//-----------------------------------------------------------------------------
// Sets the mode for the preview
//-----------------------------------------------------------------------------
void CColorZPreview::SetMode( ColorType_t type, ColorChannel_t channel )
{
if ( m_Type != type || m_Channel != channel )
{
m_Type = type;
m_Channel = channel;
DownloadTexture();
}
}
void CColorZPreview::SetColor( const RGB888_t &color, const Vector &hsvColor )
{
if ( color != m_CurrentColor || m_CurrentHSVColor != hsvColor )
{
m_CurrentColor = color;
m_CurrentHSVColor = hsvColor;
DownloadTexture();
}
}
//-----------------------------------------------------------------------------
// Lays out the panel
//-----------------------------------------------------------------------------
void CColorZPreview::PerformLayout()
{
BaseClass::PerformLayout();
int w, h;
GetSize( w, h );
Rect_t r;
r.x = MARKER_WIDTH;
r.y = MARKER_WIDTH;
r.width = w - (MARKER_WIDTH*2);
r.height = h - (MARKER_WIDTH*2);
SetPaintRect( &r );
}
//-----------------------------------------------------------------------------
// Computes a color given a particular x,y value
//-----------------------------------------------------------------------------
void CColorZPreview::ComputeColorForPoint( int y, RGB888_t &color )
{
color = m_CurrentColor;
((unsigned char*)&color)[ m_Channel ] = GetImageHeight() - y - 1;
}
void CColorZPreview::ComputeHSVColorForPoint( int y, bool bProceduralTexture, Vector &vecHSV )
{
vecHSV = m_CurrentHSVColor;
vecHSV[ m_Channel ] = (float)(GetImageHeight() - y - 1) / 255.0f;
if ( m_Channel == CHANNEL_HUE )
{
if ( vecHSV.x != -1.0f )
{
vecHSV.x *= 360.0f;
}
if ( bProceduralTexture )
{
vecHSV.y = 1.0f;
vecHSV.z = 1.0f;
}
}
}
//-----------------------------------------------------------------------------
// Fills the texture w/ the image buffer
//-----------------------------------------------------------------------------
void CColorZPreview::RegenerateTextureBits( ITexture *pTexture, IVTFTexture *pVTFTexture, Rect_t *pRect )
{
Assert( pVTFTexture->FrameCount() == 1 );
Assert( pVTFTexture->FaceCount() == 1 );
Assert( !pTexture->IsMipmapped() );
int nWidth, nHeight, nDepth;
pVTFTexture->ComputeMipLevelDimensions( 0, &nWidth, &nHeight, &nDepth );
Assert( nDepth == 1 );
Assert( nWidth == m_nWidth && nHeight == m_nHeight );
CPixelWriter pixelWriter;
pixelWriter.SetPixelMemory( pVTFTexture->Format(),
pVTFTexture->ImageData( 0, 0, 0 ), pVTFTexture->RowSizeInBytes( 0 ) );
for ( int y = 0; y < nHeight; ++y )
{
pixelWriter.Seek( 0, y );
RGB888_t color;
if ( m_Type != COLOR_TYPE_RGB )
{
Vector vecHSV;
ComputeHSVColorForPoint( y, true, vecHSV );
HSVtoRGB( vecHSV, color );
}
else
{
ComputeColorForPoint( y, color );
}
for ( int x = 0; x < nWidth; ++x )
{
pixelWriter.WritePixel( color.r, color.g, color.b, 255 );
}
}
}
//-----------------------------------------------------------------------------
// Updates the color based on the mouse position
//-----------------------------------------------------------------------------
void CColorZPreview::UpdateColorFromMouse( int x, int y )
{
int w, h;
GetSize( w, h );
h -= 2 * MARKER_WIDTH;
float flNormalizedY = (float)( y - MARKER_WIDTH ) / (h-1);
flNormalizedY = clamp( flNormalizedY, 0.0f, 1.0f );
int ty = (int)( (GetImageHeight() - 1) * flNormalizedY + 0.5f );
if ( m_Type != COLOR_TYPE_RGB )
{
Vector vecHSV;
ComputeHSVColorForPoint( ty, false, vecHSV );
KeyValues *pKeyValues = new KeyValues( "HSVSelected" );
pKeyValues->SetFloat( "hue", vecHSV.x );
pKeyValues->SetFloat( "saturation", vecHSV.y );
pKeyValues->SetFloat( "value", vecHSV.z );
PostActionSignal( pKeyValues );
// This prevents a 1-frame lag in the current color position
RGB888_t color;
HSVtoRGB( vecHSV, color );
SetColor( color, vecHSV );
}
else
{
RGB888_t color;
ComputeColorForPoint( ty, color );
Color c( color.r, color.g, color.b, 255 );
KeyValues *pKeyValues = new KeyValues( "ColorSelected" );
pKeyValues->SetColor( "color", c );
PostActionSignal( pKeyValues );
// This prevents a 1-frame lag in the current color position
Vector vecHSV;
RGBtoHSV( color, vecHSV );
SetColor( color, vecHSV );
}
}
//-----------------------------------------------------------------------------
// Handle input
//-----------------------------------------------------------------------------
void CColorZPreview::OnMousePressed( vgui::MouseCode code )
{
BaseClass::OnMousePressed( code );
if ( code == MOUSE_LEFT )
{
if ( !m_bDraggingMouse )
{
m_bDraggingMouse = true;
input()->SetMouseCapture(GetVPanel());
int x, y;
input()->GetCursorPos( x, y );
ScreenToLocal( x, y );
UpdateColorFromMouse( x, y );
}
}
}
void CColorZPreview::OnMouseReleased( vgui::MouseCode code )
{
BaseClass::OnMouseReleased( code );
if ( code == MOUSE_LEFT )
{
if ( m_bDraggingMouse )
{
m_bDraggingMouse = false;
input()->SetMouseCapture( (VPANEL)0 );
}
}
}
void CColorZPreview::OnCursorMoved( int x, int y )
{
BaseClass::OnCursorMoved( x, y );
if ( m_bDraggingMouse )
{
UpdateColorFromMouse( x, y );
}
}
//-----------------------------------------------------------------------------
// Paints the panel (the two arrows, specifically)
//-----------------------------------------------------------------------------
void CColorZPreview::Paint( void )
{
BaseClass::Paint();
int y;
if ( m_Type != COLOR_TYPE_RGB )
{
Vector vecHSVNormalized = m_CurrentHSVColor;
if ( vecHSVNormalized.x != -1.0f )
{
vecHSVNormalized.x *= 255.0f / 360.0f;
}
vecHSVNormalized.y *= 255.0f;
vecHSVNormalized.z *= 255.0f;
y = GetImageHeight() - 1 - (int)( vecHSVNormalized[ m_Channel ] + 0.5f );
}
else
{
y = GetImageHeight() - 1 - ((unsigned char*)&m_CurrentColor)[ m_Channel ];
}
// Renormalize y to actual size
int w, h;
GetSize( w, h );
h -= 2 * MARKER_WIDTH;
y = (int)( h * (float)y / 255.0f + 0.5f );
vgui::surface()->DrawSetColor( 255, 255, 255, 255 );
int px[3] = { 0, 0, MARKER_WIDTH };
int py[3] = { MARKER_WIDTH + y - MARKER_WIDTH, MARKER_WIDTH + y + MARKER_WIDTH, MARKER_WIDTH + y };
vgui::surface()->DrawPolyLine( px, py, 3 );
px[0] = px[1] = w-1;
px[2] = w - 1 - MARKER_WIDTH;
vgui::surface()->DrawPolyLine( px, py, 3 );
}
//-----------------------------------------------------------------------------
//
// Color picker panel
//
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
// constructor
//-----------------------------------------------------------------------------
CColorPickerPanel::CColorPickerPanel( vgui::Panel *pParent, const char *pName ) :
BaseClass( pParent, pName )
{
m_pColorXYPreview = new CColorXYPreview( this, "ColorXYPreview" );
m_pColorZPreview = new CColorZPreview( this, "ColorZPreview" );
m_pColorXYPreview->AddActionSignalTarget( this );
m_pHueRadio = new RadioButton( this, "HueRadio", "H" );
m_pSaturationRadio = new RadioButton( this, "SaturationRadio", "S" );
m_pValueRadio = new RadioButton( this, "ValueRadio", "V" );
m_pRedRadio = new RadioButton( this, "RedRadio", "R" );
m_pGreenRadio = new RadioButton( this, "GreenRadio", "G" );
m_pBlueRadio = new RadioButton( this, "BlueRadio", "B" );
m_pHueText = new TextEntry( this, "HueText" );
m_pSaturationText = new TextEntry( this, "SaturationText");
m_pValueText = new TextEntry( this, "ValueText" );
m_pRedText = new TextEntry( this, "RedText" );
m_pGreenText = new TextEntry( this, "GreenText" );
m_pBlueText = new TextEntry( this, "BlueText" );
m_pAlphaText= new TextEntry( this, "AlphaText" );
m_pInitialColor = new Panel( this, "InitialColor" );
m_pCurrentColor = new Panel( this, "CurrentColor" );
m_pInitialColor->SetVisible( true );
m_pCurrentColor->SetVisible( true );
m_pInitialColor->SetPaintBackgroundEnabled( true );
m_pCurrentColor->SetPaintBackgroundEnabled( true );
m_pInitialColor->SetMouseInputEnabled( false );
SetMouseInputEnabled( true );
Color c( 255, 255, 255, 255 );
SetInitialColor( c );
LoadControlSettings( "resource/colorpicker.res" );
}
//-----------------------------------------------------------------------------
// Sets the initial color
//-----------------------------------------------------------------------------
void CColorPickerPanel::SetInitialColor( Color initialColor )
{
m_InitialColor.r = initialColor.r();
m_InitialColor.g = initialColor.g();
m_InitialColor.b = initialColor.b();
m_CurrentAlpha = initialColor.a();
m_InitialAlpha = m_CurrentAlpha;
m_CurrentColor = m_InitialColor;
RGBtoHSV( m_CurrentColor, m_CurrentHSVColor );
if ( m_CurrentHSVColor.x == -1 )
{
m_CurrentHSVColor.x = 0;
}
OnColorChanged();
}
//-----------------------------------------------------------------------------
// Handle input
//-----------------------------------------------------------------------------
void CColorPickerPanel::OnMousePressed( vgui::MouseCode code )
{
BaseClass::OnMousePressed( code );
if ( code == MOUSE_LEFT )
{
// Clicking inside the initial color window
// resets the current color to the initial color
int x, y;
input()->GetCursorPos( x, y );
ScreenToLocal( x, y );
int cx, cy, cw, ch;
m_pInitialColor->GetBounds( cx, cy, cw, ch );
if ( ( cx <= x ) && ( cx+cw > x ) && ( cy <= y ) && ( cy+ch > y ) )
{
m_CurrentColor = m_InitialColor;
m_CurrentAlpha = m_InitialAlpha;
RGBtoHSV( m_CurrentColor, m_CurrentHSVColor );
if ( m_CurrentHSVColor.x == -1 )
{
m_CurrentHSVColor.x = 0;
}
OnColorChanged();
}
}
}
//-----------------------------------------------------------------------------
// Gets the current/initial color
//-----------------------------------------------------------------------------
void CColorPickerPanel::GetCurrentColor( Color *pColor )
{
pColor->SetColor( m_CurrentColor.r, m_CurrentColor.g, m_CurrentColor.b, m_CurrentAlpha );
}
void CColorPickerPanel::GetInitialColor( Color *pColor )
{
pColor->SetColor( m_InitialColor.r, m_InitialColor.g, m_InitialColor.b, m_InitialAlpha );
}
//-----------------------------------------------------------------------------
// Updates the preview colors
//-----------------------------------------------------------------------------
void CColorPickerPanel::UpdatePreviewColors()
{
Color c;
c.SetColor( m_InitialColor.r, m_InitialColor.g, m_InitialColor.b, 255 );
m_pInitialColor->SetBgColor( c );
c.SetColor( m_CurrentColor.r, m_CurrentColor.g, m_CurrentColor.b, 255 );
m_pCurrentColor->SetBgColor( c );
}
//-----------------------------------------------------------------------------
// Used to make sure we win over the scheme settings
//-----------------------------------------------------------------------------
void CColorPickerPanel::ApplySchemeSettings(IScheme *pScheme)
{
// Need to override the scheme settings for this button
BaseClass::ApplySchemeSettings( pScheme );
UpdatePreviewColors();
}
//-----------------------------------------------------------------------------
// Callbacks from the color preview dialogs
//-----------------------------------------------------------------------------
void CColorPickerPanel::OnHSVSelected( KeyValues *data )
{
m_CurrentHSVColor.x = data->GetFloat( "hue" );
m_CurrentHSVColor.y = data->GetFloat( "saturation" );
m_CurrentHSVColor.z = data->GetFloat( "value" );
HSVtoRGB( m_CurrentHSVColor, m_CurrentColor );
OnColorChanged();
}
void CColorPickerPanel::OnColorSelected( KeyValues *data )
{
Color c = data->GetColor( "color" );
m_CurrentColor.r = c.r();
m_CurrentColor.g = c.g();
m_CurrentColor.b = c.b();
RGBtoHSV( m_CurrentColor, m_CurrentHSVColor );
OnColorChanged();
}
//-----------------------------------------------------------------------------
// Radio buttons
//-----------------------------------------------------------------------------
void CColorPickerPanel::OnRadioButtonChecked( KeyValues *pKeyValues )
{
// NOTE: The radio button command strings are defined in the colorpicker.res file
// in game/platform/resource.
vgui::Panel *pPanel = (vgui::Panel *)pKeyValues->GetPtr( "panel" );
if ( pPanel == m_pRedRadio )
{
m_pColorXYPreview->SetMode( COLOR_TYPE_RGB, CHANNEL_RED );
m_pColorZPreview->SetMode( COLOR_TYPE_RGB, CHANNEL_RED );
}
else if ( pPanel == m_pGreenRadio )
{
m_pColorXYPreview->SetMode( COLOR_TYPE_RGB, CHANNEL_GREEN );
m_pColorZPreview->SetMode( COLOR_TYPE_RGB, CHANNEL_GREEN );
}
else if ( pPanel == m_pBlueRadio )
{
m_pColorXYPreview->SetMode( COLOR_TYPE_RGB, CHANNEL_BLUE );
m_pColorZPreview->SetMode( COLOR_TYPE_RGB, CHANNEL_BLUE );
}
else if ( pPanel == m_pHueRadio )
{
m_pColorXYPreview->SetMode( COLOR_TYPE_HSV, CHANNEL_HUE );
m_pColorZPreview->SetMode( COLOR_TYPE_HSV, CHANNEL_HUE );
}
else if ( pPanel == m_pSaturationRadio )
{
m_pColorXYPreview->SetMode( COLOR_TYPE_HSV, CHANNEL_SATURATION );
m_pColorZPreview->SetMode( COLOR_TYPE_HSV, CHANNEL_SATURATION );
}
else if ( pPanel == m_pValueRadio )
{
m_pColorXYPreview->SetMode( COLOR_TYPE_HSV, CHANNEL_VALUE );
m_pColorZPreview->SetMode( COLOR_TYPE_HSV, CHANNEL_VALUE );
}
}
//-----------------------------------------------------------------------------
// Called when the color changes
//-----------------------------------------------------------------------------
void CColorPickerPanel::OnColorChanged( vgui::TextEntry *pChanged )
{
char temp[256];
if ( pChanged != m_pRedText )
{
Q_snprintf( temp, sizeof(temp), "%d", m_CurrentColor.r );
m_pRedText->SetText( temp );
}
if ( pChanged != m_pGreenText )
{
Q_snprintf( temp, sizeof(temp), "%d", m_CurrentColor.g );
m_pGreenText->SetText( temp );
}
if ( pChanged != m_pBlueText )
{
Q_snprintf( temp, sizeof(temp), "%d", m_CurrentColor.b );
m_pBlueText->SetText( temp );
}
if ( pChanged != m_pAlphaText )
{
Q_snprintf( temp, sizeof( temp ), "%d", m_CurrentAlpha );
m_pAlphaText->SetText( temp );
}
if ( pChanged != m_pHueText )
{
Q_snprintf( temp, sizeof(temp), "%d", (int)(m_CurrentHSVColor.x + 0.5f) );
m_pHueText->SetText( temp );
}
if ( pChanged != m_pSaturationText )
{
Q_snprintf( temp, sizeof(temp), "%d", (int)(m_CurrentHSVColor.y * 100 + 0.5f) );
m_pSaturationText->SetText( temp );
}
if ( pChanged != m_pValueText )
{
Q_snprintf( temp, sizeof(temp), "%d", (int)(m_CurrentHSVColor.z * 100 + 0.5f) );
m_pValueText->SetText( temp );
}
m_pColorXYPreview->SetColor( m_CurrentColor, m_CurrentHSVColor );
m_pColorZPreview->SetColor( m_CurrentColor, m_CurrentHSVColor );
UpdatePreviewColors();
PostActionSignal( new KeyValues( "command", "command", "preview" ) );
}
//-----------------------------------------------------------------------------
// Called when the color text entry panels change
//-----------------------------------------------------------------------------
void CColorPickerPanel::OnTextChanged( KeyValues *data )
{
Panel *pPanel = (Panel *)data->GetPtr( "panel", NULL );
float flHue = m_CurrentHSVColor.x;
char buf[256];
if ( pPanel == m_pRedText )
{
m_pRedText->GetText( buf, sizeof(buf) );
int val = atoi( buf );
m_CurrentColor.r = clamp( val, 0, 255 );
RGBtoHSV( m_CurrentColor, m_CurrentHSVColor );
}
else if ( pPanel == m_pGreenText )
{
m_pGreenText->GetText( buf, sizeof(buf) );
int val = atoi( buf );
m_CurrentColor.g = clamp( val, 0, 255 );
RGBtoHSV( m_CurrentColor, m_CurrentHSVColor );
}
else if ( pPanel == m_pBlueText )
{
m_pBlueText->GetText( buf, sizeof(buf) );
int val = atoi( buf );
m_CurrentColor.b = clamp( val, 0, 255 );
RGBtoHSV( m_CurrentColor, m_CurrentHSVColor );
}
else if ( pPanel == m_pAlphaText )
{
m_pAlphaText->GetText( buf, sizeof( buf ) );
int val = atoi( buf );
m_CurrentAlpha = clamp( val, 0, 255 );
}
else if ( pPanel == m_pHueText )
{
m_pHueText->GetText( buf, sizeof(buf) );
int val = atoi( buf );
m_CurrentHSVColor.x = clamp( val, 0, 360 );
HSVtoRGB( m_CurrentHSVColor, m_CurrentColor );
}
else if ( pPanel == m_pSaturationText )
{
m_pSaturationText->GetText( buf, sizeof(buf) );
int val = atoi( buf );
val = clamp( val, 0, 100 );
m_CurrentHSVColor.y = (float)val / 100.0f;
HSVtoRGB( m_CurrentHSVColor, m_CurrentColor );
}
else if ( pPanel == m_pValueText )
{
m_pValueText->GetText( buf, sizeof(buf) );
int val = atoi( buf );
val = clamp( val, 0, 100 );
m_CurrentHSVColor.z = (float)val / 100.0f;
HSVtoRGB( m_CurrentHSVColor, m_CurrentColor );
}
// Preserve hue
if ( m_CurrentHSVColor.x == -1 )
{
m_CurrentHSVColor.x = flHue;
}
OnColorChanged( static_cast<vgui::TextEntry*>(pPanel) );
}
//-----------------------------------------------------------------------------
//
// Purpose: Modal picker frame
//
//-----------------------------------------------------------------------------
CColorPickerFrame::CColorPickerFrame( vgui::Panel *pParent, const char *pTitle ) :
BaseClass( pParent, "ColorPickerFrame" )
{
m_pContextKeys = NULL;
SetDeleteSelfOnClose( true );
m_pPicker = new CColorPickerPanel( this, "ColorPicker" );
m_pPicker->AddActionSignalTarget( this );
m_pOpenButton = new Button( this, "OkButton", "Ok", this, "Ok" );
m_pCancelButton = new Button( this, "CancelButton", "#FileOpenDialog_Cancel", this, "Cancel" );
SetBlockDragChaining( true );
LoadControlSettings( "resource/colorpickerframe.res" );
int w, h;
GetSize( w, h );
SetMinimumSize( w, h );
SetTitle( pTitle, false );
}
CColorPickerFrame::~CColorPickerFrame()
{
CleanUpMessage();
}
//-----------------------------------------------------------------------------
// Deletes the message
//-----------------------------------------------------------------------------
void CColorPickerFrame::CleanUpMessage()
{
if ( m_pContextKeys )
{
m_pContextKeys->deleteThis();
m_pContextKeys = NULL;
}
}
//-----------------------------------------------------------------------------
// Purpose: Activate the dialog
//-----------------------------------------------------------------------------
void CColorPickerFrame::DoModal( Color initialColor, KeyValues *pContextKeys )
{
CleanUpMessage();
m_pPicker->SetInitialColor( initialColor );
m_pContextKeys = pContextKeys;
BaseClass::DoModal();
}
//-----------------------------------------------------------------------------
// Gets the initial color
//-----------------------------------------------------------------------------
void CColorPickerFrame::GetInitialColor( Color *pColor )
{
m_pPicker->GetInitialColor( pColor );
}
//-----------------------------------------------------------------------------
// On command
//-----------------------------------------------------------------------------
void CColorPickerFrame::OnCommand( const char *pCommand )
{
if ( !Q_stricmp( pCommand, "Ok" ) )
{
Color c;
m_pPicker->GetCurrentColor( &c );
KeyValues *pActionKeys = new KeyValues( "ColorPickerPicked" );
pActionKeys->SetColor( "color", c );
if ( m_pContextKeys )
{
pActionKeys->AddSubKey( m_pContextKeys );
m_pContextKeys = NULL;
}
CloseModal();
PostActionSignal( pActionKeys );
return;
}
if ( !Q_stricmp( pCommand, "Cancel" ) )
{
vgui::input()->ReleaseAppModalSurface();
KeyValues *pActionKeys = new KeyValues( "ColorPickerCancel" );
if ( m_pContextKeys )
{
pActionKeys->AddSubKey( m_pContextKeys );
m_pContextKeys = NULL;
}
CloseModal();
PostActionSignal( pActionKeys );
return;
}
if ( !Q_stricmp( pCommand, "Preview" ) )
{
Color c;
m_pPicker->GetCurrentColor( &c );
KeyValues *pActionKeys = new KeyValues( "ColorPickerPreview" );
pActionKeys->SetColor( "color", c );
if ( m_pContextKeys )
{
pActionKeys->AddSubKey( m_pContextKeys->MakeCopy() );
}
PostActionSignal( pActionKeys );
return;
}
BaseClass::OnCommand( pCommand );
}
//-----------------------------------------------------------------------------
//
// Purpose: A button which brings up the color picker
//
//-----------------------------------------------------------------------------
CColorPickerButton::CColorPickerButton( vgui::Panel *pParent, const char *pName, vgui::Panel *pActionSignalTarget ) :
BaseClass( pParent, pName, "" )
{
m_CurrentColor.SetColor( 255, 255, 255, 255 );
if ( pActionSignalTarget )
{
AddActionSignalTarget( pActionSignalTarget );
}
}
CColorPickerButton::~CColorPickerButton()
{
}
void CColorPickerButton::ApplySchemeSettings( vgui::IScheme *pScheme )
{
BaseClass::ApplySchemeSettings( pScheme );
UpdateButtonColor();
}
//-----------------------------------------------------------------------------
// Called when the picker gets a new color
//-----------------------------------------------------------------------------
void CColorPickerButton::OnPicked( KeyValues *data )
{
SetColor( data->GetColor( "color" ) );
// Fire normal action signal messages
KeyValues *pMessage = new KeyValues( "ColorPickerPicked" );
pMessage->SetColor( "color", m_CurrentColor );
PostActionSignal( pMessage );
PlayButtonReleasedSound();
SetSelected( false );
}
//-----------------------------------------------------------------------------
// Called when a color is previewed
//-----------------------------------------------------------------------------
void CColorPickerButton::OnPreview( KeyValues *data )
{
KeyValues *pMessage = new KeyValues( "ColorPickerPreview" );
pMessage->SetColor( "color", data->GetColor( "color" ) );
PostActionSignal( pMessage );
}
//-----------------------------------------------------------------------------
// Called when cancel is hit in the picker
//-----------------------------------------------------------------------------
void CColorPickerButton::OnCancelled( )
{
SetSelected( false );
KeyValues *pMessage = new KeyValues( "ColorPickerCancel" );
pMessage->SetColor( "startingColor", m_CurrentColor );
PostActionSignal( pMessage );
}
//-----------------------------------------------------------------------------
// Perform the click
//-----------------------------------------------------------------------------
void CColorPickerButton::DoClick()
{
SetSelected( true );
CColorPickerFrame *pColorPickerDialog = new CColorPickerFrame( this, "Select Color" );
pColorPickerDialog->AddActionSignalTarget( this );
pColorPickerDialog->DoModal( m_CurrentColor );
}
//-----------------------------------------------------------------------------
// Set current color
//-----------------------------------------------------------------------------
void CColorPickerButton::SetColor( const Color& clr )
{
m_CurrentColor = clr;
UpdateButtonColor();
}
void CColorPickerButton::SetColor( int r, int g, int b, int a )
{
m_CurrentColor.SetColor( r, g, b, a );
UpdateButtonColor();
}
//-----------------------------------------------------------------------------
// Update button color
//-----------------------------------------------------------------------------
void CColorPickerButton::UpdateButtonColor()
{
SetDefaultColor( m_CurrentColor, m_CurrentColor );
SetArmedColor( m_CurrentColor, m_CurrentColor );
SetDepressedColor( m_CurrentColor, m_CurrentColor );
}