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.
78 Commits
25 Branches
6 Tags
221 MiB
Tree: 2a5b5060b4
Branches Tags
${ item.name }
Create tag ${ searchTerm }
Create branch ${ searchTerm }
from '2a5b5060b4'
${ noResults }
source-engine/vgui2/dme_controls/BaseAnimSetPresetFaderPanel...

1505 lines
40 KiB
Raw Normal View History Unescape

1
5 years ago
//========= Copyright Valve Corporation, All rights reserved. ============//
//
// Purpose:
//
//=============================================================================
#include "dme_controls/BaseAnimSetPresetFaderPanel.h"
#include "dme_controls/DmePresetGroupEditorPanel.h"
#include "vgui_controls/InputDialog.h"
#include "vgui_controls/Button.h"
#include "vgui_controls/Slider.h"
#include "vgui_controls/ComboBox.h"
#include "vgui_controls/TextImage.h"
#include "vgui_controls/TextEntry.h"
#include "vgui_controls/MessageBox.h"
#include "vgui_controls/Menu.h"
#include "vgui_controls/PanelListPanel.h"
#include "movieobjects/dmeanimationset.h"
#include "tier1/KeyValues.h"
#include "dme_controls/dmecontrols_utils.h"
#include "vstdlib/random.h"
#include "vgui/IInput.h"
#include "vgui/ISurface.h"
#include "dme_controls/BaseAnimSetAttributeSliderPanel.h"
#include "dme_controls/BaseAnimationSetEditor.h"
// memdbgon must be the last include file in a .cpp file!!!
#include "tier0/memdbgon.h"
using namespace vgui;
float ifm_fader_timescale = 5.0f;
class CPresetSlider;
//-----------------------------------------------------------------------------
// Purpose: Utility dialog, used to let user type in some text
//-----------------------------------------------------------------------------
class CAddPresetDialog : public vgui::BaseInputDialog
{
DECLARE_CLASS_SIMPLE( CAddPresetDialog, vgui::BaseInputDialog );
public:
CAddPresetDialog( vgui::Panel *parent );
void DoModal( CDmeAnimationSet *pAnimationSet, KeyValues *pContextKeyValues = NULL );
protected:
// command buttons
virtual void OnCommand(const char *command);
private:
vgui::TextEntry *m_pInput;
vgui::ComboBox *m_pPresetGroup;
};
//-----------------------------------------------------------------------------
// Constructor
//-----------------------------------------------------------------------------
CAddPresetDialog::CAddPresetDialog( vgui::Panel *parent ) : BaseClass( parent, "Enter Preset Name" )
{
m_pInput = new TextEntry( this, "PresetName" );
m_pPresetGroup = new vgui::ComboBox( this, "PresetGroup", 8, true );
SetDeleteSelfOnClose( false );
LoadControlSettings( "resource/addpresetdialog.res" );
}
void CAddPresetDialog::DoModal( CDmeAnimationSet *pAnimationSet, KeyValues *pContextKeyValues )
{
int nTextLength = m_pInput->GetTextLength() + 1;
char* pCurrentGroupName = (char*)_alloca( nTextLength * sizeof(char) );
m_pInput->GetText( pCurrentGroupName, nTextLength );
m_pPresetGroup->DeleteAllItems();
// Populate the combo box with preset group names
CDmrElementArray< CDmePresetGroup > presetGroupList = pAnimationSet->GetPresetGroups();
int nCount = presetGroupList.Count();
for ( int i = 0; i < nCount; ++i )
{
CDmePresetGroup *pPresetGroup = presetGroupList[i];
if ( pPresetGroup->m_bIsReadOnly )
continue;
KeyValues *kv = new KeyValues( "entry" );
SetElementKeyValue( kv, "presetGroup", pPresetGroup );
int nItemID = m_pPresetGroup->AddItem( pPresetGroup->GetName(), kv );
if ( pCurrentGroupName && !Q_stricmp( pPresetGroup->GetName(), pCurrentGroupName ) )
{
m_pPresetGroup->ActivateItem( nItemID );
}
}
BaseClass::DoModal( pContextKeyValues );
m_pInput->SetText( "" );
m_pInput->RequestFocus();
PlaceUnderCursor( );
}
//-----------------------------------------------------------------------------
// command handler
//-----------------------------------------------------------------------------
void CAddPresetDialog::OnCommand( const char *command )
{
if ( !Q_stricmp( command, "OK" ) )
{
int nTextLength = m_pInput->GetTextLength() + 1;
char* txt = (char*)_alloca( nTextLength * sizeof(char) );
m_pInput->GetText( txt, nTextLength );
nTextLength = m_pPresetGroup->GetTextLength() + 1;
char* pPresetGroupName = (char*)_alloca( nTextLength * sizeof(char) );
m_pPresetGroup->GetText( pPresetGroupName, nTextLength );
KeyValues *pCurrentGroup = m_pPresetGroup->GetActiveItemUserData();
CDmePresetGroup *pPresetGroup = pCurrentGroup ? GetElementKeyValue<CDmePresetGroup>( pCurrentGroup, "presetGroup" ) : NULL;
if ( pPresetGroup && Q_stricmp( pPresetGroup->GetName(), pPresetGroupName ) )
{
pPresetGroup = NULL;
}
KeyValues *kv = new KeyValues( "PresetNameSelected", "text", txt );
kv->SetString( "presetGroupName", pPresetGroupName );
SetElementKeyValue( kv, "presetGroup", pPresetGroup );
if ( m_pContextKeyValues )
{
kv->AddSubKey( m_pContextKeyValues );
m_pContextKeyValues = NULL;
}
PostActionSignal( kv );
CloseModal();
return;
}
if ( !Q_stricmp( command, "Cancel") )
{
CloseModal();
return;
}
BaseClass::OnCommand( command );
}
//-----------------------------------------------------------------------------
//
// CPresetSliderEdgeButton: The buttons that lie on either side of the PresetSlider
//
//-----------------------------------------------------------------------------
class CPresetSliderEdgeButton : public Button
{
DECLARE_CLASS_SIMPLE( CPresetSliderEdgeButton, Button );
public:
CPresetSliderEdgeButton( CPresetSlider *parent, const char *panelName, const char *text );
private:
virtual void OnCursorMoved(int x, int y);
virtual void OnMousePressed( vgui::MouseCode code );
virtual void OnMouseReleased( vgui::MouseCode code );
virtual void OnMouseDoublePressed( vgui::MouseCode code );
CPresetSlider *m_pSlider;
};
//-----------------------------------------------------------------------------
//
// CPresetSlider: The actual preset slider itself!
//
//-----------------------------------------------------------------------------
class CPresetSlider : public Slider
{
DECLARE_CLASS_SIMPLE( CPresetSlider, Slider );
public:
friend class CPresetSliderEdgeButton;
CPresetSlider( CBaseAnimSetPresetFaderPanel *parent, const char *panelName, CDmePreset *pPreset );
~CPresetSlider();
void SetControlValues( );
void SetGradientColor( const Color& clr );
float GetCurrent();
void SetPos( float frac );
AttributeDict_t *GetAttributeDict();
bool IsPreviewSlider();
bool IsDragging();
void UpdateProceduralValues();
CDmePreset *GetPreset();
protected:
virtual void Paint();
virtual void PaintBackground();
virtual void ApplySchemeSettings( IScheme *scheme );
virtual void GetTrackRect( int &x, int &y, int &w, int &h );
virtual void PerformLayout();
virtual void OnMousePressed(MouseCode code);
virtual void OnMouseDoublePressed(MouseCode code);
virtual void OnMouseReleased(MouseCode code);
virtual void OnKeyCodeTyped( KeyCode code );
virtual void OnCursorMoved(int x, int y);
MESSAGE_FUNC( OnShowContextMenu, "OnShowContextMenu" );
MESSAGE_FUNC( OnRename, "OnRename" );
MESSAGE_FUNC( OnDelete, "OnDelete" );
MESSAGE_FUNC( OnOverwrite, "OnOverwrite" );
MESSAGE_FUNC_PARAMS( OnInputCompleted, "InputCompleted", params );
MESSAGE_FUNC( OnDeleteConfirmed, "OnDeleteConfirmed" );
MESSAGE_FUNC( OnOverwriteConfirmed, "OnOverwriteConfirmed" );
private:
void OnRenameCompleted( const char *pText, KeyValues *pContextKeyValues );
void OnDragCompleted( float flValue );
void UpdateTickPos( int x, int y );
CBaseAnimSetPresetFaderPanel *m_pParent;
Color m_GradientColor;
Color m_ZeroColor;
Color m_TextColor;
Color m_TextColorFocus;
TextImage *m_pName;
float m_flCurrent;
bool m_bSuppressCompletion;
CPresetSliderEdgeButton *m_pEdgeButtons[ 2 ];
vgui::DHANDLE< vgui::Menu > m_hContextMenu;
vgui::DHANDLE< vgui::InputDialog > m_hInputDialog;
AttributeDict_t m_AttributeLookup;
vgui::DHANDLE< MessageBox > m_hConfirm;
CDmeHandle< CDmePreset > m_hSelf;
static bool s_bResetMousePosOnMouseUp;
static int s_nMousePosX;
static int s_nMousePosY;
};
//-----------------------------------------------------------------------------
//
// CPresetSliderEdgeButton: The buttons that lie on either side of the PresetSlider
//
//-----------------------------------------------------------------------------
CPresetSliderEdgeButton::CPresetSliderEdgeButton( CPresetSlider *parent, const char *panelName, const char *text ) :
BaseClass( (Panel *)parent, panelName, text ), m_pSlider( parent )
{
SetPaintBorderEnabled( false );
}
void CPresetSliderEdgeButton::OnCursorMoved(int x, int y)
{
LocalToScreen( x, y );
m_pSlider->ScreenToLocal( x, y );
m_pSlider->OnCursorMoved( x, y );
}
void CPresetSliderEdgeButton::OnMousePressed( vgui::MouseCode code )
{
BaseClass::OnMousePressed( code );
PostMessage( m_pSlider->GetVPanel(), new KeyValues( "MousePressed", "code", code ) );
PostMessage( m_pSlider->GetVPanel(), new KeyValues( "MouseReleased", "code", code ), 0.001f );
}
void CPresetSliderEdgeButton::OnMouseReleased( vgui::MouseCode code )
{
BaseClass::OnMouseReleased( code );
PostMessage( m_pSlider->GetVPanel(), new KeyValues( "MouseReleased", "code", code ) );
}
void CPresetSliderEdgeButton::OnMouseDoublePressed( vgui::MouseCode code )
{
BaseClass::OnMouseDoublePressed( code );
PostMessage( m_pSlider->GetVPanel(), new KeyValues( "MouseDoublePressed", "code", code ) );
PostMessage( m_pSlider->GetVPanel(), new KeyValues( "MouseReleased", "code", code ), 0.001f );
}
//-----------------------------------------------------------------------------
//
// CPresetSlider: The actual preset slider itself!
//
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
// Static members
//-----------------------------------------------------------------------------
bool CPresetSlider::s_bResetMousePosOnMouseUp = false;
int CPresetSlider::s_nMousePosX;
int CPresetSlider::s_nMousePosY;
//-----------------------------------------------------------------------------
// Constructor, destructor
//-----------------------------------------------------------------------------
CPresetSlider::CPresetSlider( CBaseAnimSetPresetFaderPanel *parent, const char *panelName, CDmePreset *preset ) :
BaseClass( (Panel *)parent, panelName ), m_pParent( parent ), m_bSuppressCompletion( false )
{
Assert( preset );
m_hSelf = preset;
SetRange( 0, 1000 );
SetDragOnRepositionNob( true );
SetPaintBackgroundEnabled( true );
m_pName = new TextImage( panelName );
m_pEdgeButtons[ 0 ] = new CPresetSliderEdgeButton( this, "PresetSliderLeftEdge", "" );
m_pEdgeButtons[ 1 ] = new CPresetSliderEdgeButton( this, "PresetSliderRightEdge", "" );
SetBgColor( Color( 128, 128, 128, 128 ) );
m_ZeroColor = Color( 69, 69, 69, 255 );
m_GradientColor = Color( 194, 120, 0, 255 );
m_TextColor = Color( 200, 200, 200, 255 );
m_TextColorFocus = Color( 208, 143, 40, 255 );
}
CPresetSlider::~CPresetSlider()
{
delete m_pName;
}
CDmePreset *CPresetSlider::GetPreset()
{
return m_hSelf;
}
// #define PRORCEDURAL_PRESET_TIMING
void CPresetSlider::UpdateProceduralValues()
{
if ( !m_hSelf->IsProcedural() )
return;
#if defined( PRORCEDURAL_PRESET_TIMING )
double st = Plat_FloatTime();
#endif
// Figure out what we need to do
int nPresetType = m_hSelf->GetProceduralPresetType();
switch ( nPresetType )
{
default:
Assert( 0 );
break;
case PROCEDURAL_PRESET_REVEAL:
case PROCEDURAL_PRESET_PASTE:
case PROCEDURAL_PRESET_JITTER:
case PROCEDURAL_PRESET_SMOOTH:
case PROCEDURAL_PRESET_SHARPEN:
case PROCEDURAL_PRESET_SOFTEN:
case PROCEDURAL_PRESET_STAGGER:
// These are handled elsewhere right now... at some point we'll copy in values at head position in order to do ctrl-key preview mode
break;
case PROCEDURAL_PRESET_IN_CROSSFADE:
{
m_pParent->ProceduralPreset_UpdateCrossfade( m_hSelf, true );
}
break;
case PROCEDURAL_PRESET_OUT_CROSSFADE:
{
m_pParent->ProceduralPreset_UpdateCrossfade( m_hSelf, false );
}
break;
}
#if defined( PRORCEDURAL_PRESET_TIMING )
double ed = Plat_FloatTime();
Msg( "Update %.3f msec\n", 1000.0 * ( ed - st ) );
#endif
}
//-----------------------------------------------------------------------------
// Reads the sliders, sets control values into the attribute dictionary
//-----------------------------------------------------------------------------
void CPresetSlider::SetControlValues( )
{
m_AttributeLookup.Purge();
if ( !m_hSelf.Get() )
return;
CDmrElementArray< CDmElement > values = m_hSelf->GetControlValues();
int nControlValueCount = values.Count();
for ( int i = 0; i < nControlValueCount; ++i )
{
CDmElement *v = values[ i ];
AnimationControlAttributes_t val;
val.m_pAttribute[ANIM_CONTROL_VALUE] = v->GetAttribute( "value" );
val.m_pAttribute[ANIM_CONTROL_BALANCE] = v->GetAttribute( "balance" );
val.m_pAttribute[ANIM_CONTROL_MULTILEVEL] = v->GetAttribute( "multilevel" );
val.m_pValue[ANIM_CONTROL_VALUE] = v->GetValue< float >( "value" );
val.m_pValue[ANIM_CONTROL_BALANCE] = v->GetValue< float >( "balance" );
val.m_pValue[ANIM_CONTROL_MULTILEVEL] = v->GetValue< float >( "multilevel" );
m_AttributeLookup.Insert( v->GetName(), val );
}
}
AttributeDict_t *CPresetSlider::GetAttributeDict()
{
return &m_AttributeLookup;
}
void CPresetSlider::OnMouseDoublePressed(MouseCode code)
{
if ( code != MOUSE_LEFT )
{
BaseClass::OnMouseDoublePressed( code );
return;
}
}
void CPresetSlider::OnMousePressed(MouseCode code)
{
if ( code == MOUSE_RIGHT )
return;
BaseClass::OnMousePressed( code );
if ( !_dragging )
return;
SetCursor( dc_blank );
int mx, my;
input()->GetCursorPos( mx, my );
int tx, ty, tw, th;
GetTrackRect( tx, ty, tw, th );
ScreenToLocal( mx, my );
// Off right?
bool offright = mx >= ( tx + tw ) ? true : false;
bool ctrldown = input()->IsKeyDown( KEY_LCONTROL ) || input()->IsKeyDown( KEY_RCONTROL );
if ( !ctrldown && !offright )
{
if ( mx >= tx )
{
Assert( !s_bResetMousePosOnMouseUp );
s_bResetMousePosOnMouseUp = true;
s_nMousePosX = mx;
s_nMousePosY = my;
LocalToScreen( s_nMousePosX, s_nMousePosY );
int offset = mx - tx;
mx -= offset;
LocalToScreen( mx, my );
input()->SetCursorPos( mx, my );
}
SetPos( 0 );
}
}
void CPresetSlider::OnMouseReleased(MouseCode code)
{
if ( code == MOUSE_RIGHT )
{
OnShowContextMenu();
return;
}
float flLastValue = GetCurrent();
bool bWasDragging = _dragging;
BaseClass::OnMouseReleased( code );
if ( bWasDragging )
{
OnDragCompleted( flLastValue );
SetCursor( dc_arrow );
}
if( s_bResetMousePosOnMouseUp )
{
s_bResetMousePosOnMouseUp = false;
input()->SetCursorPos( s_nMousePosX, s_nMousePosY );
}
}
void CPresetSlider::OnKeyCodeTyped( KeyCode code )
{
if ( code != KEY_ESCAPE || !_dragging )
{
BaseClass::OnKeyCodeTyped( code );
return;
}
m_bSuppressCompletion = true;
OnMouseReleased( MOUSE_LEFT );
m_bSuppressCompletion = false;
SetCursor( dc_arrow );
}
void CPresetSlider::OnDragCompleted( float flValue )
{
if ( m_bSuppressCompletion )
return;
char sz[ 128 ];
m_pName->GetText( sz, sizeof( sz ) );
// Msg( "CPresetSlider slider drag completed %s [%.3f ]\n", sz, flValue );
// Apply settings to attribute sliders
m_pParent->ApplyPreset( flValue, m_AttributeLookup );
}
void CPresetSlider::OnRename()
{
if ( m_hInputDialog.Get() )
{
delete m_hInputDialog.Get();
}
m_hInputDialog = new InputDialog( this, "Rename Preset", "Name:", GetName() );
if ( m_hInputDialog.Get() )
{
KeyValues *pContextKeyValues = new KeyValues( "RenamePreset" );
m_hInputDialog->SetSmallCaption( true );
m_hInputDialog->SetMultiline( false );
m_hInputDialog->DoModal( pContextKeyValues );
}
else
{
Assert( 0 );
}
}
void CPresetSlider::OnRenameCompleted( const char *pText, KeyValues *pContextKeyValues )
{
if ( !pText || !*pText )
{
Warning( "Can't rename preset for %s to an empty name\n", GetName() );
return;
}
// No change( case sensitive)
if ( !Q_strcmp( GetName(), pText ) )
return;
CUndoScopeGuard guard( 0, NOTIFY_SETDIRTYFLAG, "Rename Preset" );
SetName( pText );
m_pName->SetText( pText );
m_pName->ResizeImageToContent();
//
Assert( m_hSelf.Get() );
if ( m_hSelf.Get() )
{
m_hSelf->SetName( pText );
}
}
void CPresetSlider::OnInputCompleted( KeyValues *pParams )
{
const char *pText = pParams->GetString( "text", NULL );
KeyValues *pContextKeyValues = pParams->FindKey( "RenamePreset" );
if ( pContextKeyValues )
{
OnRenameCompleted( pText, pContextKeyValues );
return;
}
Assert( 0 );
}
void CPresetSlider::OnDelete()
{
if ( m_hConfirm.Get() )
delete m_hConfirm.Get();
char sz[ 256 ];
Q_snprintf( sz, sizeof( sz ), "Delete '%s'?", GetName() );
m_hConfirm = new MessageBox( "Delete Preset", sz, this );
Assert( m_hConfirm.Get() );
if ( m_hConfirm )
{
m_hConfirm->SetCancelButtonVisible( true );
m_hConfirm->SetCancelButtonText( "#VGui_Cancel" );
m_hConfirm->SetCommand( new KeyValues( "OnDeleteConfirmed" ) );
m_hConfirm->AddActionSignalTarget( this );
m_hConfirm->DoModal();
}
}
void CPresetSlider::OnDeleteConfirmed()
{
m_pParent->OnDeletePreset( m_hSelf.Get() );
}
void CPresetSlider::OnOverwrite()
{
if ( m_hConfirm.Get() )
delete m_hConfirm.Get();
char sz[ 256 ];
Q_snprintf( sz, sizeof( sz ), "Overwrite '%s'?", GetName() );
m_hConfirm = new MessageBox( "Overwrite Preset", sz, this );
Assert( m_hConfirm.Get() );
if ( m_hConfirm )
{
m_hConfirm->ShowMessageBoxOverCursor( true );
m_hConfirm->SetCancelButtonVisible( true );
m_hConfirm->SetCancelButtonText( "#VGui_Cancel" );
m_hConfirm->SetCommand( new KeyValues( "OnOverwriteConfirmed" ) );
m_hConfirm->AddActionSignalTarget( this );
m_hConfirm->DoModal();
}
}
void CPresetSlider::OnOverwriteConfirmed()
{
m_pParent->OnOverwritePreset( m_hSelf.Get() );
}
void CPresetSlider::OnShowContextMenu()
{
if ( m_hContextMenu.Get() )
{
delete m_hContextMenu.Get();
m_hContextMenu = NULL;
}
m_hContextMenu = new Menu( this, "ActionMenu" );
bool bIsReadOnly = m_hSelf.Get() ? m_hSelf->IsReadOnly() : false;
bool bCanOverwrite = !bIsReadOnly;
if ( m_hSelf->IsProcedural() )
{
switch ( m_hSelf->GetProceduralPresetType() )
{
default:
break;
case PROCEDURAL_PRESET_REVEAL:
bCanOverwrite = true;
break;
}
}
if ( bCanOverwrite )
{
m_hContextMenu->AddMenuItem( "Overwrite", new KeyValues( "OnOverwrite" ), this );
m_hContextMenu->AddSeparator();
}
if ( !bIsReadOnly )
{
m_hContextMenu->AddMenuItem( "Rename...", new KeyValues( "OnRename" ), this );
if ( Q_stricmp( GetName(), "Default" ) )
{
m_hContextMenu->AddMenuItem( "Delete...", new KeyValues( "OnDelete" ), this );
}
m_hContextMenu->AddSeparator();
}
m_hContextMenu->AddMenuItem( "Add...", new KeyValues( "AddPreset" ), m_pParent );
m_hContextMenu->AddMenuItem( "Change Crossfade Speed...", new KeyValues( "SetPresetCrossfadeSpeed" ), m_pParent );
m_hContextMenu->AddSeparator();
m_hContextMenu->AddMenuItem( "Manage...", new KeyValues( "ManagePresets" ), m_pParent );
Menu::PlaceContextMenu( this, m_hContextMenu.Get() );
}
void CPresetSlider::UpdateTickPos( int x, int y )
{
int tx, ty, tw, th;
GetTrackRect( tx, ty, tw, th );
bool bIsCtrlKeyDown = vgui::input()->IsKeyDown( KEY_LCONTROL ) || vgui::input()->IsKeyDown( KEY_RCONTROL );
bool bIsAltKeyDown = vgui::input()->IsKeyDown( KEY_LALT ) || vgui::input()->IsKeyDown( KEY_RALT );
if ( bIsCtrlKeyDown && bIsAltKeyDown && !_dragging )
{
x = tx + tw;
}
float previewValue = 0.0f;
if ( x > tx )
{
if ( x >= ( tx + tw ) || tw <= 0 )
{
previewValue = 1.0f;
}
else
{
previewValue = (float)( x - tx ) / (float)tw;
}
}
SetPos( previewValue );
}
void CPresetSlider::OnCursorMoved(int x, int y)
{
UpdateTickPos( x, y );
}
bool CPresetSlider::IsDragging()
{
return _dragging;
}
bool CPresetSlider::IsPreviewSlider()
{
VPANEL capturePanel = input()->GetMouseCapture();
if ( capturePanel )
{
if ( capturePanel != GetVPanel() )
return false;
return true;
}
VPANEL appModal = input()->GetAppModalSurface();
if ( appModal )
return false;
int mx, my;
input()->GetCursorPos( mx, my );
/*
VPANEL topMost = IsWithinTraverse( mx, my, true );
if ( topMost && topMost != GetVPanel() )
{
const char *name = ipanel()->GetName( topMost );
return false;
}
*/
return IsWithin( mx, my );
}
float CPresetSlider::GetCurrent()
{
return GetValue() * 0.001f;
}
void CPresetSlider::SetPos( float frac )
{
SetValue( (int)( frac * 1000.0f + 0.5f ), false );
}
void CPresetSlider::ApplySchemeSettings( IScheme *scheme )
{
BaseClass::ApplySchemeSettings( scheme );
m_pName->SetFont( scheme->GetFont( "DefaultBold" ) );
m_pName->SetColor( m_TextColor );
m_pName->ResizeImageToContent();
SetFgColor( Color( 194, 120, 0, 255 ) );
SetThumbWidth( 3 );
Color fullColor1( Color( 118, 71, 41, 255 ) );
Color fullColor2( Color( 194, 120, 0, 255 ) );
m_pEdgeButtons[ 0 ]->SetDefaultColor( m_ZeroColor, m_ZeroColor );
m_pEdgeButtons[ 1 ]->SetDefaultColor( fullColor1, fullColor1 );
m_pEdgeButtons[ 0 ]->SetDepressedColor( m_ZeroColor, m_ZeroColor );
m_pEdgeButtons[ 1 ]->SetDepressedColor( fullColor2, fullColor2 );
m_pEdgeButtons[ 0 ]->SetArmedColor( m_ZeroColor, m_ZeroColor );
m_pEdgeButtons[ 1 ]->SetArmedColor( fullColor1, fullColor1 );
m_pEdgeButtons[ 0 ]->SetButtonActivationType( Button::ACTIVATE_ONPRESSED );
m_pEdgeButtons[ 1 ]->SetButtonActivationType( Button::ACTIVATE_ONPRESSED );
}
void CPresetSlider::PerformLayout()
{
BaseClass::PerformLayout();
int w, h;
GetSize( w, h );
int btnSize = 9;
m_pEdgeButtons[ 0 ]->SetBounds( 3, ( h - btnSize ) / 2, btnSize, btnSize );
m_pEdgeButtons[ 1 ]->SetBounds( w - 12, ( h - btnSize ) / 2, btnSize, btnSize );
}
void CPresetSlider::GetTrackRect( int &x, int &y, int &w, int &h )
{
GetSize( w, h );
x = 15;
y = 2;
w -= 30;
h -= 4;
}
void CPresetSlider::SetGradientColor( const Color& clr )
{
m_GradientColor = clr;
}
void CPresetSlider::Paint()
{
if ( !IsPreviewSlider() )
return;
bool bIsCtrlKeyDown = vgui::input()->IsKeyDown( KEY_LCONTROL ) || vgui::input()->IsKeyDown( KEY_RCONTROL );
if ( !IsDragging() && !bIsCtrlKeyDown )
return;
int mx, my;
input()->GetCursorPos( mx, my );
ScreenToLocal( mx, my );
UpdateTickPos( mx, my );
// horizontal nob
int x, y;
int wide,tall;
GetTrackRect( x, y, wide, tall );
Color col = GetFgColor();
surface()->DrawSetColor( col );
surface()->DrawFilledRect( _nobPos[0], 1, _nobPos[1], GetTall() - 1 );
surface()->DrawSetColor( m_ZeroColor );
surface()->DrawFilledRect( _nobPos[0] - 1, y + 1, _nobPos[0], y + tall - 1 );
}
void CPresetSlider::PaintBackground()
{
int w, h;
GetSize( w, h );
bool hasFocus = IsPreviewSlider();
bool bIsCtrlKeyDown = vgui::input()->IsKeyDown( KEY_LCONTROL ) || vgui::input()->IsKeyDown( KEY_RCONTROL );
bool bIsAltKeyDown = vgui::input()->IsKeyDown( KEY_LALT ) || vgui::input()->IsKeyDown( KEY_RALT );
if ( hasFocus && ( IsDragging() || bIsCtrlKeyDown ) )
{
int tx, ty, tw, th;
GetTrackRect( tx, ty, tw, th );
surface()->DrawSetColor( Color( 0, 0, 0, 255 ) );
surface()->DrawOutlinedRect( tx, ty, tx + tw, ty + th );
surface()->DrawSetColor( m_GradientColor );
++tx;
++ty;
tw -= 2;
th -= 2;
// Gradient fill rectangle
int fillw = (int)( (float)tw * GetCurrent() + 0.5f );
int minAlpha = 15;
float alphaTarget = 255.0f;
int curAlpha = max( (int)(GetCurrent() * alphaTarget), minAlpha );
if ( _dragging )
{
surface()->DrawFilledRectFade( tx, ty, tx + fillw, ty + th, minAlpha, curAlpha, true );
surface()->DrawSetColor( m_ZeroColor );
surface()->DrawFilledRect( tx + fillw + 1, ty, tx + tw, ty + th );
}
else
{
surface()->DrawSetColor( bIsAltKeyDown ? m_GradientColor : m_ZeroColor );
surface()->DrawFilledRect( tx, ty, tx + tw, ty + th );
}
}
int cw, ch;
m_pName->SetColor( hasFocus ? m_TextColorFocus : m_TextColor );
m_pName->GetContentSize( cw, ch );
m_pName->SetPos( ( w - cw ) * 0.5f, ( h - ch ) * 0.5f );
m_pName->Paint();
}
//-----------------------------------------------------------------------------
// Slider list panel
//-----------------------------------------------------------------------------
class CSliderListPanel : public PanelListPanel
{
DECLARE_CLASS_SIMPLE( CSliderListPanel, vgui::PanelListPanel );
public:
CSliderListPanel( CBaseAnimSetPresetFaderPanel *parent, vgui::Panel *pParent, const char *panelName );
virtual void OnMouseReleased( vgui::MouseCode code );
virtual void OnMousePressed( vgui::MouseCode code );
private:
MESSAGE_FUNC( OnShowContextMenu, "OnShowContextMenu" );
vgui::DHANDLE< vgui::Menu > m_hContextMenu;
CBaseAnimSetPresetFaderPanel *m_pParent;
};
//-----------------------------------------------------------------------------
// Constructor
//-----------------------------------------------------------------------------
CSliderListPanel::CSliderListPanel( CBaseAnimSetPresetFaderPanel *pFader, vgui::Panel *pParent, const char *panelName ) :
BaseClass( pParent, panelName )
{
m_pParent = pFader;
}
//-----------------------------------------------------------------------------
// Context menu!
//-----------------------------------------------------------------------------
void CSliderListPanel::OnMousePressed( MouseCode code )
{
if ( code == MOUSE_RIGHT )
return;
BaseClass::OnMousePressed( code );
}
void CSliderListPanel::OnMouseReleased( MouseCode code )
{
if ( code == MOUSE_RIGHT )
{
OnShowContextMenu();
return;
}
BaseClass::OnMouseReleased( code );
}
//-----------------------------------------------------------------------------
// Shows the slider context menu
//-----------------------------------------------------------------------------
void CSliderListPanel::OnShowContextMenu()
{
if ( m_hContextMenu.Get() )
{
delete m_hContextMenu.Get();
m_hContextMenu = NULL;
}
m_hContextMenu = new Menu( this, "ActionMenu" );
m_hContextMenu->AddMenuItem( "Add...", new KeyValues( "AddPreset" ), m_pParent );
m_hContextMenu->AddMenuItem( "Change Crossfade Speed...", new KeyValues( "SetPresetCrossfadeSpeed" ), m_pParent );
m_hContextMenu->AddSeparator();
m_hContextMenu->AddMenuItem( "Manage...", new KeyValues( "ManagePresets" ), m_pParent );
Menu::PlaceContextMenu( this, m_hContextMenu.Get() );
}
//-----------------------------------------------------------------------------
// Constructor
//-----------------------------------------------------------------------------
CBaseAnimSetPresetFaderPanel::CBaseAnimSetPresetFaderPanel( vgui::Panel *parent, const char *className, CBaseAnimationSetEditor *editor ) :
BaseClass( parent, className ),
m_flLastFrameTime( 0.0f ),
m_pSliders( NULL ),
m_pWorkspace( NULL )
{
m_hEditor = editor;
m_pWorkspace = new EditablePanel( this, "PresetWorkspace" );
m_pWorkspace->SetPaintBackgroundEnabled( false );
m_pWorkspace->SetPaintEnabled( false );
m_pWorkspace->SetPaintBorderEnabled( false );
m_pSliders = new CSliderListPanel( this, m_pWorkspace, "PresetSliders" );
m_pSliders->SetFirstColumnWidth( 0 );
m_pSliders->SetAutoResize
(
Panel::PIN_TOPLEFT,
Panel::AUTORESIZE_DOWNANDRIGHT,
0, 24,
0, 0
);
m_pSliders->SetPos( 0, 24 );
m_pSliders->SetVerticalBufferPixels( 0 );
m_pFilter = new TextEntry( m_pWorkspace, "PresetFilter" );
m_pFilter->AddActionSignalTarget( this );
m_pFilter->SetAutoResize
(
Panel::PIN_TOPLEFT,
Panel::AUTORESIZE_RIGHT,
2, 2,
2, 22
);
m_pFilter->SetPos( 0, 0 );
m_pWorkspace->SetAutoResize
(
Panel::PIN_TOPLEFT,
Panel::AUTORESIZE_DOWNANDRIGHT,
0, 0,
0, 0
);
}
//-----------------------------------------------------------------------------
// Purpose: refreshes dialog on text changing
//-----------------------------------------------------------------------------
void CBaseAnimSetPresetFaderPanel::OnTextChanged( )
{
int nLength = m_pFilter->GetTextLength();
m_Filter.SetLength( nLength );
if ( nLength > 0 )
{
m_pFilter->GetText( m_Filter.GetForModify(), nLength+1 );
}
PopulateList( true );
}
//-----------------------------------------------------------------------------
// Called from the input dialogs used by this class
//-----------------------------------------------------------------------------
void CBaseAnimSetPresetFaderPanel::OnInputCompleted( KeyValues *pParams )
{
const char *pText = pParams->GetString( "text", NULL );
KeyValues *pContextKeyValues = pParams->FindKey( "CrossfadeSpeed" );
if ( pContextKeyValues )
{
float f = Q_atof( pText );
if ( f > 0.0f )
{
ifm_fader_timescale = f;
}
else
{
Warning( "Crossfade [%f] invalid, must be a postive number\n", f );
}
return;
}
Assert( 0 );
}
//-----------------------------------------------------------------------------
// Called from the add preset name dialogs used by this class
//-----------------------------------------------------------------------------
void CBaseAnimSetPresetFaderPanel::OnPresetNameSelected( KeyValues *pParams )
{
const char *pText = pParams->GetString( "text", NULL );
if ( !pText || !*pText )
{
vgui::MessageBox *pError = new MessageBox( "Add Preset Error", "Can't add preset with an empty name\n", this );
pError->SetDeleteSelfOnClose( true );
pError->DoModal();
return;
}
CUndoScopeGuard guard( 0, NOTIFY_SETDIRTYFLAG, "Add Preset" );
CDmePresetGroup *pPresetGroup = GetElementKeyValue<CDmePresetGroup>( pParams, "presetGroup" );
if ( !pPresetGroup )
{
const char *pGroupName = pParams->GetString( "presetGroupName" );
if ( !pGroupName )
return;
pPresetGroup = m_AnimSet->FindOrAddPresetGroup( pGroupName );
}
if ( pPresetGroup->m_bIsReadOnly )
{
vgui::MessageBox *pError = new MessageBox( "Add Preset Error", "Can't add preset to a read-only preset group!\n", this );
pError->SetDeleteSelfOnClose( true );
pError->DoModal();
return;
}
if ( pPresetGroup->FindPreset( pText ) )
{
vgui::MessageBox *pError = new MessageBox( "Add Preset Error", "A preset with that name already exists!\n", this );
pError->SetDeleteSelfOnClose( true );
pError->DoModal();
return;
}
CDmePreset *pPreset = pPresetGroup->FindOrAddPreset( pText );
AddNewPreset( pPreset );
guard.Release();
ChangeAnimationSet( m_AnimSet );
}
//-----------------------------------------------------------------------------
// The 'set crossfade speed' context menu option
//-----------------------------------------------------------------------------
void CBaseAnimSetPresetFaderPanel::OnSetCrossfadeSpeed()
{
if ( m_hInputDialog.Get() )
{
delete m_hInputDialog.Get();
}
char sz[32 ];
Q_snprintf( sz, sizeof( sz ), "%f", ifm_fader_timescale );
m_hInputDialog = new InputDialog( this, "Crossfade Speed", "Fader Crossfade Rate:", sz );
if ( m_hInputDialog.Get() )
{
KeyValues *pContextKeyValues = new KeyValues( "CrossfadeSpeed" );
m_hInputDialog->SetSmallCaption( true );
m_hInputDialog->SetMultiline( false );
m_hInputDialog->DoModal( pContextKeyValues );
}
}
//-----------------------------------------------------------------------------
// The 'add preset' context menu option
//-----------------------------------------------------------------------------
void CBaseAnimSetPresetFaderPanel::OnAddPreset()
{
if ( !m_AnimSet.Get() )
return;
if ( !m_hAddPresetDialog.Get() )
{
m_hAddPresetDialog = new CAddPresetDialog( this );
m_hAddPresetDialog->AddActionSignalTarget( this );
}
m_hAddPresetDialog->DoModal( m_AnimSet, NULL );
}
//-----------------------------------------------------------------------------
// Called by the preset group editor panel when it changes presets
//-----------------------------------------------------------------------------
void CBaseAnimSetPresetFaderPanel::OnPresetsChanged()
{
ChangeAnimationSet( m_AnimSet );
}
//-----------------------------------------------------------------------------
// Brings up the preset manager
//-----------------------------------------------------------------------------
void CBaseAnimSetPresetFaderPanel::OnManagePresets()
{
if ( !m_hPresetEditor.Get() )
{
m_hPresetEditor = new CDmePresetGroupEditorFrame( this, "Manage Presets" );
m_hPresetEditor->AddActionSignalTarget( this );
m_hPresetEditor->SetVisible( false );
m_hPresetEditor->SetDeleteSelfOnClose( false );
m_hPresetEditor->MoveToCenterOfScreen();
}
m_hPresetEditor->SetAnimationSet( m_AnimSet );
m_hPresetEditor->DoModal( );
}
void CBaseAnimSetPresetFaderPanel::ApplySchemeSettings( IScheme *scheme )
{
BaseClass::ApplySchemeSettings( scheme );
m_pSliders->SetBgColor( Color( 42, 42, 42, 255 ) );
}
void CBaseAnimSetPresetFaderPanel::GetPreviewFader( FaderPreview_t& fader )
{
Q_memset( &fader, 0, sizeof( fader ) );
fader.isbeingdragged = false;
fader.holdingctrl = input()->IsKeyDown( KEY_LCONTROL ) || input()->IsKeyDown( KEY_RCONTROL );
int mx, my;
input()->GetCursorPos( mx, my );
if ( !IsWithin( mx, my ) )
{
fader.holdingctrl = false;
}
// Walk through sliders and figure out which is under the mouse
CPresetSlider *mouseOver = NULL;
for ( int i = m_pSliders->FirstItem(); i != m_pSliders->InvalidItemID(); i = m_pSliders->NextItem(i) )
{
CPresetSlider *slider = static_cast< CPresetSlider * >( m_pSliders->GetItemPanel( i ) );
if ( !slider || !slider->IsPreviewSlider() )
continue;
mouseOver = slider;
fader.isbeingdragged = slider->IsDragging();
break;
}
if ( mouseOver )
{
// Deal with procedural presets here
if ( fader.holdingctrl ||
fader.isbeingdragged )
{
mouseOver->UpdateProceduralValues();
}
fader.name = mouseOver->GetName();
fader.amount = mouseOver->GetCurrent();
fader.values = mouseOver->GetAttributeDict();
fader.preset = mouseOver->GetPreset();
}
}
void CBaseAnimSetPresetFaderPanel::PopulateList( bool bChanged )
{
if ( !m_AnimSet.Get() )
{
m_CurrentPresetList.RemoveAll();
m_pSliders->DeleteAllItems();
return;
}
CDmrElementArray< CDmePresetGroup > presetGroups = m_AnimSet->GetPresetGroups();
Assert( presetGroups.IsValid() );
int c = presetGroups.Count();
bool bNeedRebuild = false;
int slot = 0;
for ( int i = 0 ; i < c; ++i )
{
CDmePresetGroup *pPresetGroup = presetGroups[ i ];
Assert( pPresetGroup );
if ( !pPresetGroup || !pPresetGroup->m_bIsVisible )
continue;
CDmrElementArray< CDmePreset > presets = pPresetGroup->GetPresets();
int cp = presets.Count();
for ( int j = 0; j < cp; ++j )
{
CDmePreset *pPreset = presets[ j ];
Assert( pPreset );
const char *pElementName = pPreset->GetName();
if ( Q_stricmp( pElementName, "Default" ) )
{
if ( m_Filter.Length() && !Q_stristr( pElementName, m_Filter.Get() ) )
continue;
}
if ( slot >= m_CurrentPresetList.Count() )
{
bNeedRebuild = true;
break;
}
if ( pPreset != m_CurrentPresetList[ slot ] )
{
bNeedRebuild = true;
break;
}
++slot;
}
}
if ( slot != m_CurrentPresetList.Count() )
{
bNeedRebuild = true;
}
if ( bNeedRebuild )
{
m_CurrentPresetList.RemoveAll();
m_pSliders->DeleteAllItems();
for ( int i = 0 ; i < c; ++i )
{
CDmePresetGroup *pPresetGroup = presetGroups[ i ];
Assert( pPresetGroup );
if ( !pPresetGroup || !pPresetGroup->m_bIsVisible )
continue;
CDmrElementArray< CDmePreset > presets = pPresetGroup->GetPresets();
int cp = presets.Count();
for ( int j = 0; j < cp; ++j )
{
CDmePreset *pPreset = presets[ j ];
Assert( pPreset );
const char *pElementName = pPreset->GetName();
if ( Q_stricmp( pElementName, "Default" ) )
{
if ( m_Filter.Length() && !Q_stristr( pElementName, m_Filter.Get() ) )
continue;
}
CPresetSlider *pSlider = new CPresetSlider( this, pPreset->GetName(), pPreset );
pSlider->SetPos( 0 );
pSlider->SetSize( 100, 20 );
pSlider->SetGradientColor( Color( 194, 120, 0, 255 ) );
pSlider->SetControlValues( );
m_pSliders->AddItem( NULL, pSlider );
m_CurrentPresetList.AddToTail( pPreset->GetHandle() );
}
}
}
else
{
UpdateControlValues();
}
}
void CBaseAnimSetPresetFaderPanel::ChangeAnimationSet( CDmeAnimationSet *newAnimSet )
{
bool bChanged = m_AnimSet != newAnimSet;
m_AnimSet = newAnimSet;
PopulateList( bChanged );
}
void CBaseAnimSetPresetFaderPanel::UpdateControlValues()
{
for ( int i = m_pSliders->FirstItem(); i != m_pSliders->InvalidItemID(); i = m_pSliders->NextItem(i) )
{
CPresetSlider *pSlider = static_cast< CPresetSlider * >( m_pSliders->GetItemPanel( i ) );
if ( pSlider )
{
pSlider->SetControlValues( );
}
}
}
void CBaseAnimSetPresetFaderPanel::ApplyPreset( float flScale, AttributeDict_t& dict )
{
CBaseAnimSetAttributeSliderPanel *sliderPanel = m_hEditor->GetAttributeSlider();
if ( sliderPanel )
{
sliderPanel->ApplyPreset( flScale, dict );
}
}
//-----------------------------------------------------------------------------
// Reads the current animation set control values, creates presets
//-----------------------------------------------------------------------------
void CBaseAnimSetPresetFaderPanel::SetPresetFromSliders( CDmePreset *pPreset )
{
if ( !m_AnimSet.Get() )
return;
CBaseAnimSetAttributeSliderPanel *pSliderPanel = m_hEditor->GetAttributeSlider();
if ( !pSliderPanel )
return;
CUndoScopeGuard guard( 0, NOTIFY_SETDIRTYFLAG, "Set Preset" );
const CDmrElementArray< CDmElement > controlList = m_AnimSet->GetControls();
// Now set values for each known control
int numControls = controlList.Count();
for ( int i = 0; i < numControls; ++i )
{
CDmElement *pControl = controlList[ i ];
if ( pControl->GetValue<bool>( "transform" ) )
continue;
// Facial sliders below
AttributeValue_t value;
bool bIsDefault = !pSliderPanel->GetAttributeSliderValue( &value, pControl->GetName() );
if ( !bIsDefault )
{
float flDefaultValue = pControl->GetValue< float >( "defaultValue" );
float flDefaultBalance = pControl->GetValue< float >( "defaultBalance" );
float flDefaultMultilevel = pControl->GetValue< float >( "defaultMultilevel" );
bIsDefault = ( value.m_pValue[ANIM_CONTROL_VALUE] == flDefaultValue ) &&
( value.m_pValue[ANIM_CONTROL_BALANCE] == flDefaultBalance ) &&
( value.m_pValue[ANIM_CONTROL_MULTILEVEL] == flDefaultMultilevel );
}
// Blow away preset values for controls that contain the default values
if ( bIsDefault )
{
pPreset->RemoveControlValue( pControl->GetName() );
continue;
}
bool bIsCombo = pControl->GetValue< bool >( "combo" );
bool bIsMulti = pControl->GetValue< bool >( "multi" );
// Stamp the control value
CDmElement *pControlValue = pPreset->FindOrAddControlValue( pControl->GetName() );
pControlValue->SetValue< float >( "value", value.m_pValue[ANIM_CONTROL_VALUE] );
if ( bIsCombo )
{
pControlValue->SetValue< float >( "balance", value.m_pValue[ANIM_CONTROL_BALANCE] );
}
else
{
pControlValue->RemoveAttribute( "balance" );
}
if ( bIsMulti )
{
pControlValue->SetValue< float >( "multilevel", value.m_pValue[ANIM_CONTROL_MULTILEVEL] );
}
else
{
pControlValue->RemoveAttribute( "multilevel" );
}
}
}
void CBaseAnimSetPresetFaderPanel::AddNewPreset( CDmePreset *pPreset )
{
if ( !pPreset )
return;
SetPresetFromSliders( pPreset );
CPresetSlider *pSlider = new CPresetSlider( this, pPreset->GetName(), pPreset );
if ( pSlider )
{
pSlider->SetPos( 0 );
pSlider->SetSize( 100, 20 );
pSlider->SetGradientColor( Color( 194, 120, 0, 255 ) );
pSlider->SetControlValues( );
m_pSliders->AddItem( NULL, pSlider );
}
}
void CBaseAnimSetPresetFaderPanel::OnAddNewPreset( KeyValues *pKeyValues )
{
CDmePreset *pPreset = GetElementKeyValue<CDmePreset>( pKeyValues, "preset" );
CUndoScopeGuard guard( 0, NOTIFY_SETDIRTYFLAG, "Overwrite Preset" );
AddNewPreset( pPreset );
guard.Release();
ChangeAnimationSet( m_AnimSet );
}
void CBaseAnimSetPresetFaderPanel::AddNewPreset( const char *pGroupName, const char *pName )
{
if ( !m_AnimSet.Get() )
return;
CBaseAnimSetAttributeSliderPanel *sliderPanel = m_hEditor->GetAttributeSlider();
if ( !sliderPanel )
return;
CUndoScopeGuard guard( 0, NOTIFY_SETDIRTYFLAG, "Add Preset" );
CDmePresetGroup *pPresetGroup = m_AnimSet->FindOrAddPresetGroup( pGroupName );
CDmePreset *pPreset = pPresetGroup->FindOrAddPreset( pName );
AddNewPreset( pPreset );
guard.Release();
ChangeAnimationSet( m_AnimSet );
}
void CBaseAnimSetPresetFaderPanel::OnOverwritePreset( CDmePreset *pPreset )
{
SetPresetFromSliders( pPreset );
UpdateControlValues();
}
void CBaseAnimSetPresetFaderPanel::OnDeletePreset( CDmePreset *pPreset )
{
{
// Delete it from various things
CUndoScopeGuard guard( 0, NOTIFY_SETDIRTYFLAG, "Delete Preset" );
m_AnimSet->RemovePreset( pPreset );
}
ChangeAnimationSet( m_AnimSet );
}
void CBaseAnimSetPresetFaderPanel::ProceduralPreset_UpdateCrossfade( CDmePreset *pPreset, bool bFadeIn )
{
// Handled by derived class in SFM
}