mirror of
https://github.com/nillerusr/source-engine.git
synced 2024-12-22 06:06:50 +00:00
1256 lines
35 KiB
C++
1256 lines
35 KiB
C++
//========= 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 );
|
|
}
|