tf2/tf2_src/vgui2/dme_controls/BaseAnimSetAttributeSliderPanel.cpp

//========= Copyright Valve Corporation, All rights reserved. ============//
//
// Purpose: 
//
//=============================================================================

#include "dme_controls/BaseAnimSetAttributeSliderPanel.h"
#include "movieobjects/dmechannel.h"
#include "movieobjects/dmeanimationset.h"
#include "vgui_controls/TextImage.h"
#include "vgui_controls/Button.h"
#include "vgui_controls/Slider.h"
#include "vgui_controls/PanelListPanel.h"
#include "dme_controls/BaseAnimSetPresetFaderPanel.h"
#include "dme_controls/BaseAnimationSetEditor.h"
#include "dme_controls/attributeslider.h"
#include "vgui/ISurface.h"
#include "vgui/ISystem.h"
#include "vgui/IInput.h"


// memdbgon must be the last include file in a .cpp file!!!
#include "tier0/memdbgon.h"

using namespace vgui;

#define ANIMATION_SET_EDITOR_ATTRIBUTESLIDERS_BUTTONTRAY_HEIGHT 32
#define ANIMATION_SET_EDITOR_ATTRIBUTESLIDERS_BUTTONTRAY_YPOS 0

//-----------------------------------------------------------------------------
// Enums
//-----------------------------------------------------------------------------
#define SLIDER_PIXEL_SPACING 3
#define RECOMPUTE_PREVIEW_INTERVAL ( 0.5f )
#define CIRCULAR_CONTROL_RADIUS 6.0f
#define FRAC_PER_PIXEL 0.0025f

static ConVar ifm_attributesliderbalance_sensitivity( "ifm_attributesliderbalance_sensitivity", "1.0", 0 );

extern float ifm_fader_timescale;

enum
{
	// Just some arbitrary number that we're not likely to see in another .lib or the main app's code
	UNDO_CHAIN_MOUSEWHEEL_ATTRIBUTE_SLIDER = 9876,
};


bool CBaseAnimSetAttributeSliderPanel::ChannelToSliderLookup_t::Less( const ChannelToSliderLookup_t& lhs, const ChannelToSliderLookup_t& rhs )
{
	return lhs.ch.Get() < rhs.ch.Get();
}


//-----------------------------------------------------------------------------
// Blends flex values in left-right space instead of balance/value space
//-----------------------------------------------------------------------------
static void BlendFlexValues( AttributeValue_t *pResult, const AttributeValue_t &src, const AttributeValue_t &dest, float flBlend, float flBalanceFilter = 0.5f )
{
	// Apply the left-right balance to the target
	float flLeftFilter, flRightFilter;
	ValueBalanceToLeftRight( &flLeftFilter, &flRightFilter, flBlend, flBalanceFilter );

	// Do the math in 'left-right' space because we filter in that space
	float flSrcLeft, flSrcRight;
	ValueBalanceToLeftRight( &flSrcLeft, &flSrcRight, src.m_pValue[ANIM_CONTROL_VALUE], src.m_pValue[ANIM_CONTROL_BALANCE] );

	float flDestLeft, flDestRight;
	ValueBalanceToLeftRight( &flDestLeft, &flDestRight, dest.m_pValue[ANIM_CONTROL_VALUE], dest.m_pValue[ANIM_CONTROL_BALANCE] );

	float flTargetLeft = flSrcLeft + flLeftFilter * ( flDestLeft - flSrcLeft );
	float flTargetRight = flSrcRight + flRightFilter * ( flDestRight - flSrcRight );

	LeftRightToValueBalance( &pResult->m_pValue[ANIM_CONTROL_VALUE], &pResult->m_pValue[ANIM_CONTROL_BALANCE], flTargetLeft, flTargetRight, 
		( flBlend <= 0.5f ) ? src.m_pValue[ANIM_CONTROL_BALANCE] : dest.m_pValue[ANIM_CONTROL_BALANCE] );

	pResult->m_pValue[ANIM_CONTROL_MULTILEVEL] = src.m_pValue[ANIM_CONTROL_MULTILEVEL] + ( dest.m_pValue[ANIM_CONTROL_MULTILEVEL] - src.m_pValue[ANIM_CONTROL_MULTILEVEL] ) * flBlend;
}


//-----------------------------------------------------------------------------
//
// CPresetSideFilterSlider class begins
//
//-----------------------------------------------------------------------------
class CPresetSideFilterSlider : public Slider
{
	DECLARE_CLASS_SIMPLE( CPresetSideFilterSlider, Slider );

public:
	CPresetSideFilterSlider( CBaseAnimSetAttributeSliderPanel *pParent, const char *panelName );
	virtual ~CPresetSideFilterSlider();

	float		GetPos();
	void		SetPos( float frac );

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 OnMousePressed(MouseCode code);
	virtual void OnMouseDoublePressed(MouseCode code);

private:
	CBaseAnimSetAttributeSliderPanel	*m_pParent;

	Color			m_ZeroColor;
	Color			m_TextColor;
	Color			m_TextColorFocus;
	TextImage		*m_pName;
	float			m_flCurrent;
};


//-----------------------------------------------------------------------------
// Constructor, destructor
//-----------------------------------------------------------------------------
CPresetSideFilterSlider::CPresetSideFilterSlider( CBaseAnimSetAttributeSliderPanel *parent, const char *panelName ) :
	BaseClass( (Panel *)parent, panelName ), m_pParent( parent )
{
	SetRange( 0, 1000 );
	SetDragOnRepositionNob( true );
	SetPos( 0.5f );
	SetPaintBackgroundEnabled( true );

	m_pName = new TextImage( "Preset Side Filter" );

	SetBgColor( Color( 128, 128, 128, 128 ) );

	m_ZeroColor = Color( 33, 33, 33, 255 );
	m_TextColor = Color( 200, 200, 200, 255 );
	m_TextColorFocus = Color( 208, 143, 40, 255 );
}

CPresetSideFilterSlider::~CPresetSideFilterSlider()
{
	delete m_pName;
}

void CPresetSideFilterSlider::OnMousePressed(MouseCode code)
{
	if ( code == MOUSE_RIGHT )
	{
		SetPos( 0.5f );
		return;
	}

	BaseClass::OnMousePressed( code );
}

void CPresetSideFilterSlider::OnMouseDoublePressed(MouseCode code)
{
	if ( code == MOUSE_LEFT )
	{
		SetPos( 0.5f );
		return;
	}

	BaseClass::OnMouseDoublePressed( code );
}

float CPresetSideFilterSlider::GetPos()
{
	return GetValue() * 0.001f;
}

void CPresetSideFilterSlider::SetPos( float frac )
{
	SetValue( (int)( frac * 1000.0f + 0.5f ), false );
}

void CPresetSideFilterSlider::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 );
}

void CPresetSideFilterSlider::GetTrackRect( int &x, int &y, int &w, int &h )
{
	GetSize( w, h );
	x = 0;
	y = 2;
	h -= 4;
}

void CPresetSideFilterSlider::Paint()
{
	// 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 CPresetSideFilterSlider::PaintBackground()
{
	int w, h;
	GetSize( w, h );
			   
	int tx, ty, tw, th;
	GetTrackRect( tx, ty, tw, th );
	surface()->DrawSetColor( m_ZeroColor );
	surface()->DrawFilledRect( tx, ty, tx + tw, ty + th );

	int cw, ch;
	m_pName->SetColor( _dragging ? m_TextColorFocus : m_TextColor );
	m_pName->GetContentSize( cw, ch );
	m_pName->SetPos( ( w - cw ) * 0.5f, ( h - ch ) * 0.5f );
	m_pName->Paint();
}


//-----------------------------------------------------------------------------
//
// CBaseAnimSetAttributeSliderPanel begins
//
//-----------------------------------------------------------------------------
CBaseAnimSetAttributeSliderPanel::CBaseAnimSetAttributeSliderPanel( vgui::Panel *parent, const char *className, CBaseAnimationSetEditor *editor ) :
	BaseClass( parent, className ),
	m_flEstimatedValue( 0.0f ),
	m_ChannelToSliderLookup( 0, 0, ChannelToSliderLookup_t::Less ),
	m_flRecomputePreviewTime( -1.0f ),
	m_bRequestedNewPreview( false ),
	m_flPrevTime( 0.0f ),
	m_nFaderChangeFlags( 0 )
{
	m_hEditor = editor;

	m_pLeftRightBoth[ 0 ] = new Button( this, "AttributeSliderLeftOnly", "", this, "OnLeftOnly" );
	m_pLeftRightBoth[ 1 ] = new Button( this, "AttributeSliderRightOnly", "", this, "OnRightOnly" );
	m_pPresetSideFilter = new CPresetSideFilterSlider( this, "PresetSideFilter" );
	m_Sliders = new PanelListPanel( this, "AttributeSliders" );
	m_Sliders->SetFirstColumnWidth( 0 );
	m_Sliders->SetAutoResize
		( 
		Panel::PIN_TOPLEFT, 
		Panel::AUTORESIZE_DOWNANDRIGHT,
		0, ANIMATION_SET_EDITOR_ATTRIBUTESLIDERS_BUTTONTRAY_HEIGHT,
		0, 0
		);
	m_Sliders->SetVerticalBufferPixels( 0 );

	m_PreviousPreviewFader = "";
	m_Previous.isbeingdragged = false;
	m_Previous.holdingctrl = false;
	m_Previous.amount = 0.0f;
}

void CBaseAnimSetAttributeSliderPanel::OnCommand( const char *pCommand )
{
	if ( !Q_stricmp( pCommand, "OnLeftOnly" ) )
	{
		m_pPresetSideFilter->SetPos( 0.0f );
		return;
	}

	if ( !Q_stricmp( pCommand, "OnRightOnly" ) )
	{
		m_pPresetSideFilter->SetPos( 1.0f );
		return;
	}

	BaseClass::OnCommand( pCommand );
}

void CBaseAnimSetAttributeSliderPanel::StampValueIntoLogs( CDmElement *control, AnimationControlType_t type, float flValue )
{
}

void CBaseAnimSetAttributeSliderPanel::ApplySchemeSettings( IScheme *scheme )
{
	BaseClass::ApplySchemeSettings( scheme );
	m_Sliders->SetBgColor( Color( 42, 42, 42, 255 ) );
}

void CBaseAnimSetAttributeSliderPanel::PerformLayout()
{
	BaseClass::PerformLayout();

	int w, h;
	GetSize( w, h );

	int availH = ANIMATION_SET_EDITOR_ATTRIBUTESLIDERS_BUTTONTRAY_HEIGHT;
				 	 
	int btnSize = 9;
	m_pLeftRightBoth[ 0 ]->SetBounds( 15, ( availH - btnSize ) / 2, btnSize, btnSize );
	m_pLeftRightBoth[ 1 ]->SetBounds( w - 15, ( availH - btnSize ) / 2, btnSize, btnSize );
	m_pPresetSideFilter->SetBounds( 23 + btnSize, 4, w - 38 - 2 * btnSize, availH - 8 );
}



//-----------------------------------------------------------------------------
// Purpose: Determines:
//  a) are we holding the ctrl key still, if so
//     figures out the crossfade amount of each preset slider with non-zero influence
//  b) not holding control, then just see if we are previewing whichever preset the mouse is over
// Input  :  - 
//-----------------------------------------------------------------------------
void CBaseAnimSetAttributeSliderPanel::OnThink()
{
	BaseClass::OnThink();

	CBaseAnimSetPresetFaderPanel *presets = m_hEditor->GetPresetFader();
	if ( !presets )
		return;

	FaderPreview_t fader;
	presets->GetPreviewFader( fader );

	bool nameChanged = ( fader.name && ( m_PreviousPreviewFader.IsEmpty() || Q_stricmp( m_PreviousPreviewFader.Get(), fader.name ) ) ) ? true : false;
	bool beingDraggedChanged = fader.isbeingdragged != m_Previous.isbeingdragged ? true : false;
	bool ctrlKeyChanged = fader.holdingctrl != m_Previous.holdingctrl ? true : false;
	bool bFaderChanged = ( nameChanged || beingDraggedChanged || ctrlKeyChanged );
	bool bPresetChanged = fader.preset != m_Previous.preset;
	bool faderAmountChanged = fader.amount != m_Previous.amount ? true : false;

	m_nFaderChangeFlags = 0;
	if ( nameChanged ) 
	{
		m_nFaderChangeFlags |= FADER_NAME_CHANGED;
	}
	if ( beingDraggedChanged )
	{
		m_nFaderChangeFlags |= FADER_DRAG_CHANGED;
	}
	if ( ctrlKeyChanged )
	{
		m_nFaderChangeFlags |= FADER_CTRLKEY_CHANGED;
	}
	if ( faderAmountChanged )
	{
		m_nFaderChangeFlags |= FADER_AMOUNT_CHANGED;
	}
	if ( bPresetChanged )
	{
		m_nFaderChangeFlags |= FADER_PRESET_CHANGED;
	}

	m_PreviousPreviewFader = fader.name;
	m_Previous = fader;

	int c = m_SliderList.Count();
	for ( int i = 0; i < c; ++i )
	{
		CAttributeSlider *slider = m_SliderList[ i ];
		slider->EnablePreview( false, false, false );
		if ( !slider->IsVisible() )
			continue;

		if ( !slider->GetControl() )
			continue;

		const char *name = slider->GetName();
		Assert( name );

		if ( m_CtrlKeyPreviewSlider.Get() == slider )
		{
			// The preset stuff shouldn't be active when we're holding ctrl over the raw attribute sliders!!!
			Assert( !fader.isbeingdragged );
			m_CtrlKeyPreviewSliderElement = NULL;
			m_CtrlKeyPreviewSlider = NULL;

			AttributeValue_t dest;
			if ( !slider->IsTransform() )
			{
				dest.m_pValue[ ANIM_CONTROL_VALUE ] = m_flEstimatedValue;
				dest.m_pValue[ ANIM_CONTROL_BALANCE ] = slider->GetValue( ANIM_CONTROL_BALANCE );
				dest.m_pValue[ ANIM_CONTROL_MULTILEVEL ] = slider->GetValue( ANIM_CONTROL_MULTILEVEL );
			}
			else
			{
				dest.m_pValue[ ANIM_CONTROL_VALUE ] = 0.0f;
				dest.m_pValue[ ANIM_CONTROL_BALANCE ] = 0.5f;
				dest.m_pValue[ ANIM_CONTROL_MULTILEVEL ] = 0.5f;
			}

			// If we aren't over any of the preset sliders, then we need to be able to ramp down to the current value, too
			slider->EnablePreview( true, false, false );
			slider->SetPreview( dest, dest, true, true );
			continue;
		}

		if ( !fader.values )
			continue;

		AttributeValue_t preview;
		preview.m_pValue[ ANIM_CONTROL_VALUE ] = slider->IsTransform() ? 0.0f : slider->GetControlDefaultValue( ANIM_CONTROL_VALUE );
		preview.m_pValue[ ANIM_CONTROL_BALANCE ] = 0.5f;
		preview.m_pValue[ ANIM_CONTROL_MULTILEVEL ] = 0.5f;

		AttributeValue_t current = slider->GetValue();

		int idx = fader.values->Find( name );
		if ( idx != fader.values->InvalidIndex() )
		{
			preview = (*fader.values)[ idx ];
		}
		BlendFlexValues( &preview, current, preview, 1.0f, slider->IsControlActive( ANIM_CONTROL_BALANCE ) ? m_pPresetSideFilter->GetPos() : 0.5f );

		bool simple = fader.isbeingdragged || ( !fader.holdingctrl && !slider->IsRampingTowardPreview() && !ctrlKeyChanged );

		slider->EnablePreview( true, simple, fader.isbeingdragged );
		if ( bFaderChanged || fader.isbeingdragged )
		{
			// If being dragged, slam to current value right away
			if ( simple )
			{
				slider->SetPreview( preview, preview, true, true );
			}
			else
			{
				// For the "ramp down" case (just released ctrl key), we need the original values instead of the preview valuees
				if ( ctrlKeyChanged && !fader.holdingctrl && slider->IsRampingTowardPreview() )
				{
					Assert( !fader.isbeingdragged );
					slider->RampDown();
				}
				else
				{
					// Apply the left-right balance to the target
					AttributeValue_t dest;
					BlendFlexValues( &dest, current, preview, fader.amount );
					slider->SetPreview( dest, preview, !fader.holdingctrl, !nameChanged );
				}
			}
		}

		if ( faderAmountChanged || fader.isbeingdragged || fader.holdingctrl )
		{
			slider->UpdateFaderAmount( fader.amount );
		}
	}

	UpdatePreviewSliderTimes();

	ApplySliderValues( false );

	PerformRecomputePreview();
}

void CBaseAnimSetAttributeSliderPanel::ChangeAnimationSet( CDmeAnimationSet *newAnimSet )
{
	int i;
	// Force recomputation
	m_nActiveControlSetMode = -1;

	bool rebuild = true;

	if ( m_AnimSet.Get() &&	newAnimSet == m_AnimSet )
	{
		// See if every slider is the same as before
		const CDmaElementArray< CDmElement > &controls = m_AnimSet->GetControls();
		int controlCount = controls.Count();
		if ( m_SliderList.Count() == controlCount )
		{
			rebuild = false;
			for ( i = 0 ; i < controlCount; ++i )
			{
				CDmElement *control = controls[ i ];
				if ( !control )
					continue;

				if ( Q_stricmp( control->GetName(), m_SliderList[ i ]->GetName() ) )
				{
					rebuild = true;
					break;
				}

				bool bStereo =  control->GetValue< bool >( "combo" );
				bool bIsMulti =  control->GetValue< bool >( "multi" );
				if ( m_SliderList[ i ]->IsControlActive( ANIM_CONTROL_BALANCE ) != bStereo || 
					 m_SliderList[ i ]->IsControlActive( ANIM_CONTROL_MULTILEVEL ) != bIsMulti )
				{
					rebuild = true;
					break;
				}
			}
		}
	}

	m_AnimSet = newAnimSet;

	if ( !m_AnimSet.Get() )
		return;

	if ( !rebuild )
		return;

	int c = m_SliderList.Count();
	for ( i = 0 ; i < c; ++i )
	{
		delete m_SliderList[ i ];
	}
	m_SliderList.RemoveAll();
	m_Sliders->RemoveAll();
	m_ChannelToSliderLookup.Purge();

	const CDmaElementArray< CDmElement > &controls = m_AnimSet->GetControls();

	// Now create sliders for all known controls, nothing visible by default
	int controlCount = controls.Count();
	for ( i = 0 ; i < controlCount; ++i )
	{
		CDmElement *control = controls[ i ];
		if ( !control )
			continue;

		CAttributeSlider *slider = new CAttributeSlider( this, control->GetName(), control );

		slider->SetVisible( false );
		slider->SetValue( ANIM_CONTROL_VALUE, control->GetValue< float >( "value" ) );
		slider->SetSize( 100, 20 );

		bool bStereo = control->GetValue< bool >( "combo" );
		slider->ActivateControl( ANIM_CONTROL_BALANCE, bStereo );
		if ( bStereo )
		{
			slider->SetValue( ANIM_CONTROL_BALANCE, control->GetValue< float >( "balance" ) );
		}

		bool bMulti = control->GetValue< bool >( "multi" );
		slider->ActivateControl( ANIM_CONTROL_MULTILEVEL, bMulti );
		if ( bMulti )
		{
			slider->SetValue( ANIM_CONTROL_MULTILEVEL, control->GetValue< float >( "multilevel" ) );
		}
		m_SliderList.AddToTail( slider );

		ChannelToSliderLookup_t lookup;
		lookup.slider	= control;

		CDmeChannel *ctrlChannels[ LOG_PREVIEW_MAX_CHANNEL_COUNT ];
		GetChannelsForControl( control, ctrlChannels );
		for ( int j = 0 ; j < LOG_PREVIEW_MAX_CHANNEL_COUNT; ++j )
		{
			lookup.ch = ctrlChannels[ j ];
			lookup.type	= (AnimationControlType_t)j;
			if ( lookup.ch )
			{
				Assert( m_ChannelToSliderLookup.Find( lookup) == m_ChannelToSliderLookup.InvalidIndex() );
				m_ChannelToSliderLookup.Insert( lookup );
			}
		}
	}

	RecomputePreview();
}

void CBaseAnimSetAttributeSliderPanel::SetVisibleControlsForSelectionGroup( CUtlSymbolTable& visible )
{
	int i, c;

	bool changed = false;

	// Walk through all sliders and show only those in the symbol table
	c = m_SliderList.Count();
	for ( i = 0; i < c; ++i )
	{
		CAttributeSlider *slider = m_SliderList[ i ];
		const char *sliderName = slider->GetName();

		bool showSlider = visible.Find( sliderName ) != UTL_INVAL_SYMBOL ? true : false;
		if ( slider->IsVisible() != showSlider )
		{
			changed = true;
			break;
		}
	}

	if ( !changed )
		return;

	m_Sliders->RemoveAll();
	c = m_SliderList.Count();
	for ( i = 0; i < c; ++i )
	{
		CAttributeSlider *slider = m_SliderList[ i ];
		const char *sliderName = slider->GetName();

		if ( visible.Find( sliderName ) != UTL_INVAL_SYMBOL )
		{
			slider->SetVisible( true );
			m_Sliders->AddItem( NULL, slider );
		}
		else
		{
			slider->SetVisible( false );
		}
	}

	// Force mode to recompute
	m_nActiveControlSetMode = -1;
	RecomputePreview();
}


void CBaseAnimSetAttributeSliderPanel::ApplyPreset( float flScale, AttributeDict_t& values )
{
	int c = m_SliderList.Count();
	for ( int i = 0; i < c; ++i )
	{
		CAttributeSlider *slider = m_SliderList[ i ];
		if ( !slider || !slider->IsVisible() )
			continue;

		if ( slider->IsTransform() )
			continue;

		AttributeValue_t current, target;
		current = slider->GetValue( );

		target.m_pValue[ ANIM_CONTROL_VALUE ] = slider->GetControlDefaultValue( ANIM_CONTROL_VALUE );
		target.m_pValue[ ANIM_CONTROL_BALANCE ] = 0.5f;
		target.m_pValue[ ANIM_CONTROL_MULTILEVEL ] = 0.5f;

		const char *name = slider->GetName();
		int idx = name ? values.Find( name ) : values.InvalidIndex();
		if ( idx != values.InvalidIndex() )
		{
			target = values[ idx ];
		}

		// Apply the left-right balance to the target
		AttributeValue_t blend;
		BlendFlexValues( &blend, current, target, flScale, slider->IsControlActive( ANIM_CONTROL_BALANCE ) ? m_pPresetSideFilter->GetPos() : 0.5f );
		slider->SetValue( blend );
	}
}

static const char *s_pAnimControlAttribute[ANIM_CONTROL_COUNT] = 
{
	"value", "balance", "multilevel"
};

bool CBaseAnimSetAttributeSliderPanel::ApplySliderValues( bool bForce )
{
	if ( !m_AnimSet.Get() )
		return false;

	if ( !bForce )
	{
		bForce = m_Previous.isbeingdragged;
	}

	const CDmaElementArray< CDmElement > &controls = m_AnimSet->GetControls();

	bool valuesChanged = false;

	CDisableUndoScopeGuard guard;

	int c = m_SliderList.Count();
	for ( int i = 0; i < c; ++i )
	{
		CAttributeSlider *pSlider = m_SliderList[ i ];
		if ( !pSlider->IsVisible() )
			continue;

		CDmElement *pControl = controls[ i ];
		if ( !pControl )
			continue;

		// Skip these types of sliders...
		if ( pControl->GetValue< bool >( "transform" ) )
			continue;

		CDmeChannel *ctrlChannels[ LOG_PREVIEW_MAX_CHANNEL_COUNT ];
		GetChannelsForControl( pControl, ctrlChannels );

		bool bUsePreviewValue = pSlider->IsPreviewEnabled() && ( !pSlider->IsSimplePreview() || bForce );

		for ( int j = 0; j < LOG_PREVIEW_MAX_CHANNEL_COUNT; ++j )
		{
			AnimationControlType_t type = (AnimationControlType_t)j;
			CDmeChannel *pChannel = ctrlChannels[ j ];

			// Figure out what to do based on the channel's mode
			ChannelMode_t mode = pChannel ? pChannel->GetMode() : CM_PASS;
			bool bPushSlidersIntoScene = ( mode == CM_PASS || mode == CM_RECORD );
			bool bPullSlidersFromScene = ( mode == CM_PLAY );

			if ( bPullSlidersFromScene )
			{
				Assert( pChannel );

				// If it's actively being manipulated, the UI will be up to date
				if ( pSlider->GetDragControl() == type )
					continue;

				// If we're dragging value, we're now going to be changing balance as well
				if ( pSlider->GetDragControl() == ANIM_CONTROL_VALUE && type == ANIM_CONTROL_BALANCE )
					continue;

				// Drive value setting based on the output data
				// NOTE: GetCurrentPlaybackValue might not overwrite flValue.
				float flValue = pSlider->GetControlDefaultValue( type );
				pChannel->GetCurrentPlaybackValue< float >( flValue );
				pSlider->SetValue( type, flValue );
				pControl->SetValue< float >( s_pAnimControlAttribute[type], flValue );
			}
			else if ( bPushSlidersIntoScene )
			{
				float flValue = bUsePreviewValue ? pSlider->GetPreview( type ) : pSlider->GetValue( type );
				if ( pControl->GetValue< float >( s_pAnimControlAttribute[type] ) != flValue || bForce )
				{
					valuesChanged = true;
					pControl->SetValue< float >( s_pAnimControlAttribute[type], flValue );
				}
			}
		}
	}

	guard.Release();

	return valuesChanged;
}

void CBaseAnimSetAttributeSliderPanel::UpdatePreviewSliderTimes()
{
	if ( !m_AnimSet.Get() )
		return;

	const CDmaElementArray< CDmElement > &controls = m_AnimSet->GetControls();

	float curtime = system()->GetFrameTime();
	float dt = clamp( curtime - m_flPrevTime, 0.0f, 0.1f );
	m_flPrevTime = curtime;

	dt *= ifm_fader_timescale;

	bool previewing = false;
	bool changingvalues = false;

	bool ctrlDown = input()->IsKeyDown( KEY_LCONTROL ) || input()->IsKeyDown( KEY_RCONTROL );
	int mx, my;
	input()->GetCursorPos( mx, my );
	if ( ctrlDown )
	{
		bool bInside = m_Sliders->IsWithin( mx, my );
		if ( !bInside )
		{
			ctrlDown = false;
		}

		VPANEL topMost = input()->GetMouseOver();
		if ( topMost && !ipanel()->HasParent( topMost, GetVPanel() ) )
		{
			ctrlDown = false;
		}
	}

	CAttributeSlider *dragSlider = NULL;
	CDmElement *dragSliderElement = NULL;

	m_CtrlKeyPreviewSliderElement = NULL;
	m_CtrlKeyPreviewSlider = NULL;
	m_flEstimatedValue = 0.0f;

	int c = m_SliderList.Count();
	for ( int i = 0; i < c; ++i )
	{
		CAttributeSlider *slider = m_SliderList[ i ];
		slider->UpdateTime( dt );

		if ( !slider->IsVisible() )
			continue;

		bool ctrlDownOnThisSlider = false;
		if ( ctrlDown )
		{
			int x, y;
			x = mx;
			y = my;
			slider->ScreenToLocal( x, y );

			int sw, st;
			slider->GetSize( sw, st );
			if ( x >= 0 && x < sw && y >= 0 && y < st )
			{
				// Should only hit one slider!!!
				Assert( !ctrlDownOnThisSlider );
				ctrlDownOnThisSlider = true;
				if ( !slider->IsTransform() )
				{
					m_flEstimatedValue = slider->EstimateValueAtPos( x, y );
				}
			}
		}

		if ( slider->IsPreviewEnabled() )
		{
			if ( !slider->IsSimplePreview() )
			{
				previewing = true;
			}
		}
		// If a fader is being dragged, or we're directly manipulating the slider, then we are going to put
		//  this slider into record mode
		if ( slider->IsFaderBeingDragged() )
		{
			changingvalues = true;
			Assert( !dragSlider );
			dragSlider = NULL;
			dragSliderElement = NULL;
		}
		else if ( slider->IsDragging() )
		{
			Assert( !dragSlider );
			dragSlider = slider;
			dragSliderElement = controls[ i ];
			changingvalues = true;
		}

		if ( ctrlDownOnThisSlider )
		{
			m_CtrlKeyPreviewSliderElement = controls[ i ];
			m_CtrlKeyPreviewSlider = slider;
		}
	}

	switch ( m_hEditor->GetRecordingState() )
	{
	default:
		Assert( 0 );
		break;
	case AS_OFF:
		{
			ActivateControlSetInMode( CM_OFF, CM_OFF, CM_OFF, NULL );
		}
		break;
	case AS_RECORD:
		{
			// Put one or all things into record mode (if dragging a single slider, other channels should be in playback mode)
			if ( changingvalues || previewing )
			{
				ActivateControlSetInMode( changingvalues ? CM_RECORD : CM_PASS, CM_PLAY, CM_PLAY, dragSlider );
			}
			else
			{
				ActivateControlSetInMode( CM_PLAY, CM_PLAY, CM_PLAY, dragSlider );
			}
		}
		break;
	case AS_PLAYBACK:
		{
			// Put things into playback, except if dragging a slider, to preview
			if ( changingvalues || previewing )
			{
				ActivateControlSetInMode( CM_PASS, CM_PLAY, CM_PLAY, NULL );
			}
			else
			{
				ActivateControlSetInMode( CM_PLAY, CM_PLAY, CM_PLAY, NULL );
			}
		}
		break;
	case AS_PREVIEW:
		{
			// Put things into passthru
			ActivateControlSetInMode( CM_PASS, CM_PASS, CM_PLAY, NULL );
		}
		break;
	}

	if ( dragSliderElement )
	{
		SetLogPreviewControl( dragSliderElement );
	}
	else if ( m_CtrlKeyPreviewSliderElement.Get() )
	{
		SetLogPreviewControl( m_CtrlKeyPreviewSliderElement );
	}
}

bool CBaseAnimSetAttributeSliderPanel::GetAttributeSliderValue( AttributeValue_t *pValue, const char *name )
{
	int c = m_SliderList.Count();
	for ( int i = 0; i < c; ++i )
	{
		CAttributeSlider *slider = m_SliderList[ i ];
		if ( Q_stricmp( slider->GetName(), name ) )
			continue;

		*pValue = slider->GetValue( );
		return true;
	}
	return false;
}

void CBaseAnimSetAttributeSliderPanel::GetChannelsForControl( CDmElement *control, CDmeChannel *channels[LOG_PREVIEW_MAX_CHANNEL_COUNT] )
{
	if ( control->GetValue< bool >( "transform" ) )
	{
		CDmeChannel *ch1 = control->GetValueElement< CDmeChannel >( "position" );
		CDmeChannel *ch2 = control->GetValueElement< CDmeChannel >( "orientation" );

		channels[ LOG_PREVIEW_POSITION ] = ch1;
		channels[ LOG_PREVIEW_ORIENTATION ] = ch2;
		for ( int i = 2; i < LOG_PREVIEW_MAX_CHANNEL_COUNT; ++i )
		{
			channels[i] = NULL;
		}
		return;
	}

	if ( control->GetValue< bool >( "combo" ) )
	{
		channels[ LOG_PREVIEW_VALUE ] = control->GetValueElement< CDmeChannel >( "valuechannel" );
		channels[ LOG_PREVIEW_BALANCE ] = control->GetValueElement< CDmeChannel >( "balancechannel" );
	}
	else
	{
		channels[ LOG_PREVIEW_VALUE ] = control->GetValueElement< CDmeChannel >( "channel" );
		channels[ LOG_PREVIEW_BALANCE ] = 0;
	}

	if ( control->GetValue< bool >( "multi" ) )
	{
		channels[ LOG_PREVIEW_MULTILEVEL ] = control->GetValueElement< CDmeChannel >( "multilevelchannel" );
	}
	else
	{
		channels[ LOG_PREVIEW_MULTILEVEL ] = NULL;
	}
	for ( int i = 3; i < LOG_PREVIEW_MAX_CHANNEL_COUNT; ++i )
	{
		channels[i] = NULL;
	}
}

void CBaseAnimSetAttributeSliderPanel::GetActiveTimeSelectionParams( DmeLog_TimeSelection_t& params )
{
	Assert( 0 );
}

void CBaseAnimSetAttributeSliderPanel::ActivateControlSetInMode( int mode, int otherChannelsMode, int hiddenChannelsMode, CAttributeSlider *whichSlider /*= NULL*/ )
{
	int i, c;

	if ( !m_AnimSet.Get() )
		return;

	bool updateChannelsModeChanged = m_nActiveControlSetMode != mode ? true : false;
	if ( !updateChannelsModeChanged )
		return;

	int previousMode = m_nActiveControlSetMode;
	m_nActiveControlSetMode = mode;

	if ( previousMode == CM_RECORD )
	{
		DmeLog_TimeSelection_t	params;
		GetActiveTimeSelectionParams( params );

		// Finalize any previously recording layers!!!
		g_pChannelRecordingMgr->FinishLayerRecording( params.m_flThreshold, true );
	}

	ChannelMode_t channelMode = ( ChannelMode_t )mode;

	const CDmaElementArray< CDmElement > &controls = m_AnimSet->GetControls();

	// Build the list of channels to alter
	CUtlVector< CDmeChannel * >	updateChannels;
	CUtlVector< CDmeChannel * >	otherChannels;
	CUtlVector< CDmeChannel * >	hiddenChannels;

	CDisableUndoScopeGuard guard;

	c = m_SliderList.Count();
	int j;
	for ( i = 0; i < c; ++i )
	{
		CAttributeSlider *slider = m_SliderList[ i ];
		CDmElement *ctrl = controls[ i ];
		if ( !ctrl )
			continue;

		CDmeChannel *ctrlChannels[ LOG_PREVIEW_MAX_CHANNEL_COUNT ];
		GetChannelsForControl( ctrl, ctrlChannels );

		for ( j = 0 ; j < LOG_PREVIEW_MAX_CHANNEL_COUNT; ++j )
		{								    
			if ( !ctrlChannels[ j ] )
				continue;

			CUtlVector< CDmeChannel * > *useArray = NULL;;

			// now characterize it
			bool hidden = !slider->IsVisible();
			if ( hidden )
			{
				useArray = &hiddenChannels;
			}
			else
			{
				if ( !whichSlider )
				{
					useArray = &updateChannels;
				}
				else if ( slider == whichSlider )
				{
					// this causes value and balance to get lumped together, since we're now dragging left/right values
					if ( slider->GetDragControl() == ANIM_CONTROL_MULTILEVEL )
					{
						useArray = ( j == LOG_PREVIEW_MULTILEVEL ) ? &updateChannels : &otherChannels;
					}
					else
					{
						useArray = ( j != LOG_PREVIEW_MULTILEVEL ) ? &updateChannels : &otherChannels;
					}
				}
				else
				{
					useArray = &otherChannels;
				}
			}

			useArray->AddToTail( ctrlChannels[ j ] );
		}
	}

	guard.Release();

	c = updateChannels.Count();
	if ( c > 0 )
	{
		if ( channelMode == CM_RECORD )
		{
			DmeLog_TimeSelection_t	params;
			GetActiveTimeSelectionParams( params );
			params.SetRecordingMode( ( NULL == whichSlider ) ? RECORD_PRESET : RECORD_ATTRIBUTESLIDER );

			g_pChannelRecordingMgr->StartLayerRecording( "Dragging Sliders", &params );

			for ( i = 0; i < c; ++i )
			{
				// THIS PUTS THEM INTO CM_RECORD
				g_pChannelRecordingMgr->AddChannelToRecordingLayer( updateChannels[ i ], GetCurrentMovie(), GetCurrentShot() );
			}

			SetTimeSelectionParametersForRecordingChannels( ( NULL == whichSlider ) ? m_Previous.amount : 1.0f );
		}
		else
		{
			// Don't create undo records for this
			CDisableUndoScopeGuard guardSet;
			for ( i = 0; i < c; ++i )
			{
				updateChannels[ i ]->SetMode( channelMode );
			}
		}
	}

	c = otherChannels.Count();
	if ( c > 0 )
	{
		// Don't create undo records for this
		CDisableUndoScopeGuard guardRecord;

		for ( i = 0; i < c; ++i )
		{
			// These should never go into record!!!
			Assert( (ChannelMode_t)otherChannelsMode != CM_RECORD );
			otherChannels[ i ]->SetMode( (ChannelMode_t)otherChannelsMode );
		}
	}

	c = hiddenChannels.Count();
	if ( c > 0 )
	{
		// Don't create undo records for this
		CDisableUndoScopeGuard guardRecord;

		// For now these should only be able to go into Playback
		//Assert( (ChannelMode_t)hiddenChannelsMode == CM_PLAY );

		for ( i = 0; i < c; ++i )
		{
			hiddenChannels[ i ]->SetMode( (ChannelMode_t)hiddenChannelsMode );
		}
	}
}

static const char *s_pDefaultAttributeName[ANIM_CONTROL_COUNT] = 
{
	"defaultValue", "defaultBalance", "defaultMultilevel"
};

void CBaseAnimSetAttributeSliderPanel::SetupForPreset( FaderPreview_t &fader, int nChangeFlags )
{
	// Nothing special here
}

float CBaseAnimSetAttributeSliderPanel::GetBalanceSliderValue()
{
	return m_pPresetSideFilter->GetPos();
}

void CBaseAnimSetAttributeSliderPanel::SetTimeSelectionParametersForRecordingChannels( float flIntensity )
{
	CBaseAnimSetPresetFaderPanel *pPresets = m_hEditor->GetPresetFader();
	if ( !pPresets )
	{
		Assert( 0 );
		return;
	}

	FaderPreview_t fader;
	pPresets->GetPreviewFader( fader );

	SetupForPreset( fader, m_nFaderChangeFlags );

	int c = g_pChannelRecordingMgr->GetLayerRecordingChannelCount();
	for ( int i = 0; i < c; ++i )
	{
		CDmeChannel *ch = g_pChannelRecordingMgr->GetLayerRecordingChannel( i );
		if ( !ch )
			continue;

		CDmAttribute *pPreset = NULL;

		ChannelToSliderLookup_t search;
		search.ch = ch;
		unsigned int idx = m_ChannelToSliderLookup.Find( search );
		if ( idx != m_ChannelToSliderLookup.InvalidIndex() && fader.values )
		{
			ChannelToSliderLookup_t &item = m_ChannelToSliderLookup[ idx ];

			CDmElement *pControl = item.slider;
			Assert( pControl );

			int faderIndex = fader.values->Find( pControl->GetName() );
			if ( faderIndex != fader.values->InvalidIndex() )
			{
				pPreset = (*fader.values)[ faderIndex ].m_pAttribute[ item.type ];
			}
			if ( !pPreset )
			{
				pPreset = pControl->GetAttribute( s_pDefaultAttributeName[item.type] );
			}
		}

		g_pChannelRecordingMgr->SetPresetValue( ch, pPreset );
	}
}

static bool CanPreviewType( DmAttributeType_t attType )
{
	switch ( attType )
	{
	default:
		return false;
	case AT_FLOAT:
	case AT_VECTOR3:
	case AT_QUATERNION:
		break;
	}
	return true;
}

void CBaseAnimSetAttributeSliderPanel::MaybeAddPreviewLog( CDmeFilmClip *shot, CUtlVector< LogPreview_t >& list, CDmElement *control, bool bDragging, bool isActiveLog, bool bSelected )
{
	CDmeChannel *ctrlChannels[ LOG_PREVIEW_MAX_CHANNEL_COUNT ];
	GetChannelsForControl( control, ctrlChannels );

	LogPreview_t preview;

	preview.m_bDragging = bDragging;
	preview.m_bActiveLog = isActiveLog;
	preview.m_bSelected = bSelected;

	for ( int channel = 0; channel < LOG_PREVIEW_MAX_CHANNEL_COUNT; ++channel )
	{
		CDmeChannel *ch = ctrlChannels[ channel ];
		if ( !ch )
			continue;

		CDmeLog *log = ch->GetLog();
		if ( !log )
			continue;

		DmAttributeType_t attType = log->GetDataType();
		if ( !CanPreviewType( attType ) )
			continue;

		Assert( control );

		preview.m_hControl = control;
		preview.m_hShot	= shot;
		preview.m_hChannels[ channel ] = ch;
		preview.m_hOwner = ch->FindOwnerClipForChannel( shot );
	}

	list.AddToTail( preview );
}

void CBaseAnimSetAttributeSliderPanel::RecomputePreview()
{
	float curtime = system()->GetFrameTime();
	m_flRecomputePreviewTime = curtime + RECOMPUTE_PREVIEW_INTERVAL;
	m_bRequestedNewPreview = true;
}

CDmeFilmClip *CBaseAnimSetAttributeSliderPanel::GetCurrentShot()
{
	return NULL;
}

CDmeFilmClip *CBaseAnimSetAttributeSliderPanel::GetCurrentMovie()
{
	return NULL;
}

void CBaseAnimSetAttributeSliderPanel::PerformRecomputePreview()
{
	m_CurrentPreview.RemoveAll();
	if ( !m_bRequestedNewPreview )
		return;

#if 0
	// Tracker 54528:  While this saves recomputing things all of the time, the delay is annoying so 
	//  we'll turn it off for now
	float curtime = system()->GetFrameTime();
	if ( curtime < m_flRecomputePreviewTime )
		return;
#endif

	m_bRequestedNewPreview = false;
	m_flRecomputePreviewTime = -1.0f;
	// list of bones/root transforms which are in the control set
	m_ActiveTransforms.Purge(); 
	if ( !m_AnimSet.Get() )
		return;

	CDmeFilmClip *shot = GetCurrentShot();
	CDmElement *previewControl = GetLogPreviewControl();
	const CDmaElementArray< CDmElement > &controls = m_AnimSet->GetControls();

	int c = m_SliderList.Count();
	int i;
	for ( i = 0; i < c; ++i )
	{
		CAttributeSlider *slider = m_SliderList[ i ];
		if ( !slider->IsVisible() )
			continue;
		CDmElement *control = controls[ i ];

		MaybeAddPreviewLog( shot, m_ActiveTransforms, control, slider->IsDragging(), false, slider->IsSelected() );
		MaybeAddPreviewLog( shot, m_CurrentPreview, control, slider->IsDragging(), ( control == previewControl ), slider->IsSelected() );
	}
}

CUtlVector< LogPreview_t >* CBaseAnimSetAttributeSliderPanel::GetActiveTransforms()
{
	return &m_ActiveTransforms;
}

CDmElement *CBaseAnimSetAttributeSliderPanel::GetElementFromSlider( CAttributeSlider *pSlider )
{
	const CDmaElementArray< CDmElement > &controls = m_AnimSet->GetControls();

	int c = m_SliderList.Count();
	int i;
	for ( i = 0; i < c; ++i )
	{
		CAttributeSlider *slider = m_SliderList[ i ];
		if ( slider != pSlider )
			continue;

		CDmElement *control = controls[ i ];
		return control;
	}
	return NULL;
}

CDmElement *CBaseAnimSetAttributeSliderPanel::GetLogPreviewControl()
{
	return m_PreviewControl.Get();
}

void CBaseAnimSetAttributeSliderPanel::SetLogPreviewControlFromSlider( CAttributeSlider *pSlider )
{
	CDmElement *control = GetElementFromSlider( pSlider );
	// Note can be NULL
	SetLogPreviewControl( control );
}

void CBaseAnimSetAttributeSliderPanel::SetLogPreviewControl( CDmElement *control )
{
	if ( !m_hEditor.Get() )
		return;

	bool changed = m_PreviewControl != control ? true : false;
	m_PreviewControl = control;
	if ( changed )
	{
		const CDmaElementArray< CDmElement > &controls = m_AnimSet->GetControls();

		int itemNumber = 0;
		int nSliders = m_SliderList.Count();
		for ( int i = 0; i < nSliders; ++i )
		{
			CAttributeSlider *slider = m_SliderList[ i ];
			slider->SetIsLogPreviewControl( false );
			if ( !slider->IsVisible() )
				continue;

			CDmElement *c = controls[ i ];
			if ( c == control )
			{
				slider->SetIsLogPreviewControl( true );
				slider->RequestFocus();
				m_Sliders->ScrollToItem( itemNumber );
			}

			++itemNumber;
		}

		RecomputePreview();
	}
}


void CBaseAnimSetAttributeSliderPanel::GetVisibleControls( CUtlVector< VisItem_t>& list )
{
	const CDmaElementArray< CDmElement > &controls = m_AnimSet->GetControls();

	int i, c;
	c = m_SliderList.Count();
	for ( i = 0; i < c; ++i )
	{
		CAttributeSlider *slider = m_SliderList[ i ];
		if ( !slider->IsVisible() )
			continue;

		CDmElement *ctrl = controls[ i ];
		if ( !ctrl )
			continue;

		VisItem_t item;
		item.element = ctrl;
		item.selected = slider->IsSelected();
		item.index = i;

		list.AddToTail( item );
	}
}

int CBaseAnimSetAttributeSliderPanel::BuildVisibleControlList( CUtlVector< LogPreview_t >& list )
{
	if ( !m_AnimSet.Get() )
		return 0;

	const CDmaElementArray< CDmElement > &controls = m_AnimSet->GetControls();

	int i, c;
	c = m_SliderList.Count();
	for ( i = 0; i < c; ++i )
	{
		CAttributeSlider *slider = m_SliderList[ i ];
		if ( !slider->IsVisible() )
			continue;

		CDmElement *ctrl = controls[ i ];
		if ( !ctrl )
			continue;

		MaybeAddPreviewLog( NULL, list, ctrl, slider->IsDragging(), false, slider->IsSelected() );
	}

	return list.Count();
}

int CBaseAnimSetAttributeSliderPanel::BuildFullControlList( CUtlVector< LogPreview_t >& list )
{
	if ( !m_AnimSet.Get() )
		return 0;

	const CDmaElementArray< CDmElement > &controls = m_AnimSet->GetControls();

	int i, c;
	c = m_SliderList.Count();
	for ( i = 0; i < c; ++i )
	{
		CAttributeSlider *slider = m_SliderList[ i ];
		CDmElement *ctrl = controls[ i ];
		if ( !ctrl )
			continue;

		MaybeAddPreviewLog( NULL, list, ctrl, slider->IsDragging(), false, slider->IsSelected() );
	}

	return list.Count();
}




void SpewLayer( const char *desc, CDmeTypedLogLayer< float > *l )
{
	Msg( "%s\n", desc );

	int c = l->GetKeyCount();
	for ( int i = 0; i < c; ++i )
	{
		DmeTime_t kt = l->GetKeyTime( i );
		float v = l->GetKeyValue( i );

		Msg( "%d %.3f = %f\n", i, kt.GetSeconds(), v );

		if ( i > 20 )
			break;

	}
}

void CBaseAnimSetAttributeSliderPanel::MoveToSlider( CAttributeSlider *pCurrentSlider, int nDirection )
{
	Assert( pCurrentSlider );
	if ( !pCurrentSlider )
		return;

	// Find current slider index and then move to next / previous one
	CUtlVector< CAttributeSlider * > visible;

	int c = m_SliderList.Count();
	if ( c <= 1 )
		return;

	int i;
	for ( i = 0; i < c; ++i )
	{
		if ( !m_SliderList[ i ]->IsVisible() )
			continue;
		visible.AddToTail( m_SliderList[ i ] );
	}

	c = visible.Count();

	if ( c <= 1 )
		return;

	for ( i = 0; i < c; ++i )
	{
		if ( visible[ i ] != pCurrentSlider )
			continue;

		Msg( "Found slider at %d (old %s)\n", i, pCurrentSlider->GetName() );

		i += nDirection;
		if ( i < 0 )
		{
			i = c - 1;
		}
		else if ( i >= c )
		{
			i = 0;
		}

		Msg( "Change to slider %d %s\n", i, visible[ i ]->GetName() );

		// m_SliderList[ i ]->RequestFocus();
		SetLogPreviewControl( visible[ i ]->GetControl() );
		break;
	}
}

void CBaseAnimSetAttributeSliderPanel::OnKBDeselectAll()
{
	ClearSelectedControls();
}

void CBaseAnimSetAttributeSliderPanel::ClearSelectedControls()
{
	int c = m_SliderList.Count();
	int i;
	for ( i = 0; i < c; ++i )
	{
		m_SliderList[ i ]->SetSelected( false );
	}
	RecomputePreview();
}

void CBaseAnimSetAttributeSliderPanel::SetControlSelected( CAttributeSlider *slider, bool state )
{
	slider->SetSelected( state);
	RecomputePreview();
}

void CBaseAnimSetAttributeSliderPanel::SetControlSelected( CDmElement *control, bool state )
{
	CAttributeSlider *slider = FindSliderForControl( control );
	if ( !slider )
		return;
	SetControlSelected( slider, state );
}

CAttributeSlider *CBaseAnimSetAttributeSliderPanel::FindSliderForControl( CDmElement *control )
{
	int c = m_SliderList.Count();
	int i;
	for ( i = 0; i < c; ++i )
	{
		if ( m_SliderList[ i ]->GetControl() == control )
			return m_SliderList[ i ];
	}

	return NULL;
}

bool CBaseAnimSetAttributeSliderPanel::GetSliderValues( AttributeValue_t *pValue, int nIndex )
{
	Assert( pValue );
	Assert( nIndex >= 0 && nIndex < m_SliderList.Count() );

	CAttributeSlider *pSlider = m_SliderList[ nIndex ];
	bool bForce = m_Previous.isbeingdragged;
	bool bGetPreview = ( pSlider->IsPreviewEnabled() && ( !pSlider->IsSimplePreview() || bForce ) );
	*pValue = bGetPreview ? pSlider->GetPreview() : pSlider->GetValue();
	return pSlider->IsVisible();
}