tf2/tf2_src/utils/hlfaceposer/expressiontool.cpp

//========= Copyright Valve Corporation, All rights reserved. ============//
//
// Purpose: 
//
// $NoKeywords: $
//
//=============================================================================//
#include <stdio.h>
#include "hlfaceposer.h"
#include "ExpressionTool.h"
#include "mdlviewer.h"
#include "choreowidgetdrawhelper.h"
#include "TimelineItem.h"
#include "expressions.h"
#include "expclass.h"
#include "choreoevent.h"
#include "StudioModel.h"
#include "choreoscene.h"
#include "choreoactor.h"
#include "choreochannel.h"
#include "ChoreoView.h"
#include "InputProperties.h"
#include "ControlPanel.h"
#include "FlexPanel.h"
#include "mxExpressionTray.h"
#include "ExpressionProperties.h"
#include "tier1/strtools.h"
#include "faceposer_models.h"
#include "UtlBuffer.h"
#include "filesystem.h"
#include "iscenetokenprocessor.h"
#include "MatSysWin.h"
#include "choreoviewcolors.h"
#include "scriplib.h"
#include "EdgeProperties.h"

ExpressionTool *g_pExpressionTool = 0;

#define TRAY_HEIGHT 55 

#define TRAY_ITEM_INSET 10

#define MAX_TIME_ZOOM 1000
// 10% per step
#define TIME_ZOOM_STEP 2

void SetupFlexControllerTracks( CStudioHdr *hdr, CChoreoEvent *event );

class CExpressionToolWorkspace : public mxWindow
{
public:
	CExpressionToolWorkspace( mxWindow *parent );
	~CExpressionToolWorkspace();

	virtual int			handleEvent( mxEvent *event );
	virtual void		redraw( void );
	virtual bool		PaintBackground( void )
	{
		redraw();
		return false;
	}

	void				RepositionVSlider( void );
	int					ComputeVPixelsNeeded( void );
	// Playback tick
	void				Think( float dt );

	void				LayoutItems( bool force = false );

	void				HideTimelines( void );
	void				CollapseAll( TimelineItem *keepExpanded );

	void				ExpandAll( void );
	void				ExpandValid( void );
	void				DisableAllExcept( void );
	void				EnableValid( void );

	TimelineItem		*GetItem( int number );
	TimelineItem		*GetClickedItem( void );
	void				ClearClickedItem( void );

	void				OnSnapAll();
	void				OnDeleteColumn();

	void				MoveSelectedSamples( float dfdx, float dfdy, bool snap );
	void				DeleteSelectedSamples( void );
	int					CountSelectedSamples( void );
	void				DeselectAll( void );
	void				SelectPoints( float start, float end );

	void				DrawEventEnd( CChoreoWidgetDrawHelper& drawHelper );

	void				OnSortByUsed( void );
	void				OnSortByName( void );

private:

	int					GetItemUnderMouse( int mx, int my );

	void				MouseToToolMouse( int& mx, int& my, char *reason );

	TimelineItem		*m_pItems[ GLOBAL_STUDIO_FLEX_CONTROL_COUNT ];

	// The scroll bars
	mxScrollbar			*m_pVertScrollBar;
	int					m_nLastVPixelsNeeded;

	int					m_nTopOffset;
	int					m_nScrollbarHeight;

	int					m_nItemGap;
	int					m_nFocusItem;
};

CExpressionToolWorkspace::CExpressionToolWorkspace( mxWindow *parent ) :
	mxWindow( parent, 0, 0, 0, 0 )
{
	HWND wnd = (HWND)getHandle();
	DWORD style = GetWindowLong( wnd, GWL_STYLE );
	style |= WS_CLIPCHILDREN | WS_CLIPSIBLINGS;
	SetWindowLong( wnd, GWL_STYLE, style );

	for ( int i = 0; i < GLOBAL_STUDIO_FLEX_CONTROL_COUNT; i++ )
	{
		m_pItems[ i ] = new TimelineItem( this );
	}

	m_nItemGap		= 2;

	m_nScrollbarHeight = 12;
	m_nTopOffset	= 0;

	m_nLastVPixelsNeeded = -1;

	m_pVertScrollBar = new mxScrollbar( this, 0, 0, 12, 100, IDC_EXPRESSIONTOOLVSCROLL, mxScrollbar::Vertical );

	m_nFocusItem = -1;

	HideTimelines();
	LayoutItems();
}

CExpressionToolWorkspace::~CExpressionToolWorkspace()
{
}

void CExpressionToolWorkspace::redraw()
{
	CChoreoWidgetDrawHelper drawHelper( this );

	DrawEventEnd( drawHelper );

	for ( int i = 0; i < GLOBAL_STUDIO_FLEX_CONTROL_COUNT; i++ )
	{
		TimelineItem *item = GetItem( i );
		if ( !item )
			continue;

		if ( !item->GetVisible() )
			continue;

		RECT rcBounds;
		item->GetBounds( rcBounds );

		if ( rcBounds.bottom < 0 )
			continue;
		if ( rcBounds.top > h2() )
			continue;

		item->Draw( drawHelper );
	}
}

//-----------------------------------------------------------------------------
// Purpose: 
// Input  : *elem1 - 
//			*elem2 - 
// Output : int
//-----------------------------------------------------------------------------
int SortFuncByUse(const void *elem1, const void *elem2 )
{
	TimelineItem *item1 = *( TimelineItem ** )elem1;
	TimelineItem *item2 = *( TimelineItem ** )elem2;

	if ( item1->IsValid() == item2->IsValid() )
		return 0;

	if ( !item2->IsValid() && item1->IsValid() )
		return -1;

	return 1;
}

//-----------------------------------------------------------------------------
// Purpose: 
// Input  : *elem1 - 
//			*elem2 - 
// Output : int
//-----------------------------------------------------------------------------
int SortFuncByName(const void *elem1, const void *elem2 )
{
	TimelineItem *item1 = *( TimelineItem ** )elem1;
	TimelineItem *item2 = *( TimelineItem ** )elem2;

	CFlexAnimationTrack *track1 = item1->GetSafeTrack();
	CFlexAnimationTrack *track2 = item2->GetSafeTrack();

	if ( !track1 || !track2 )
	{
		if ( track1 )
			return -1;
		if ( track2 )
			return 1;
		return 0;
	}

	return stricmp( track1->GetFlexControllerName(), track2->GetFlexControllerName() );
}

void CExpressionToolWorkspace::OnSortByUsed( void )
{
	qsort( m_pItems, GLOBAL_STUDIO_FLEX_CONTROL_COUNT, sizeof( TimelineItem * ), SortFuncByUse );
	LayoutItems( false );
}

void CExpressionToolWorkspace::OnSortByName( void )
{
	qsort( m_pItems, GLOBAL_STUDIO_FLEX_CONTROL_COUNT, sizeof( TimelineItem * ), SortFuncByName );
	LayoutItems( false );
}

void CExpressionToolWorkspace::DrawEventEnd( CChoreoWidgetDrawHelper& drawHelper )
{
	if ( !g_pExpressionTool )
		return;

	CChoreoEvent *e = g_pExpressionTool->GetSafeEvent();
	if ( !e )
		return;

	float duration = e->GetDuration();
	if ( !duration )
		return;

	int leftx = g_pExpressionTool->GetPixelForTimeValue( duration ) -5;
	if ( leftx >= w2() )
		return;

	RECT rcClient;
	drawHelper.GetClientRect( rcClient );

	drawHelper.DrawColoredLine(
		COLOR_CHOREO_ENDTIME, PS_SOLID, 1,
		leftx, rcClient.top, leftx, rcClient.bottom );

}

int CExpressionToolWorkspace::GetItemUnderMouse( int mx, int my )
{
	POINT pt;
	pt.x = mx;
	pt.y = my;

	for ( int i = 0; i < GLOBAL_STUDIO_FLEX_CONTROL_COUNT; i++ )
	{
		TimelineItem *item = GetItem( i );
		if ( !item )
			continue;

		if ( !item->GetVisible() )
			continue;

		RECT rc;
		item->GetBounds( rc );

		if ( PtInRect( &rc, pt ) )
		{
			return i;
		}
	}

	return -1;
}

void CExpressionToolWorkspace::MouseToToolMouse( int& mx, int& my, char *reason )
{
	POINT pt;
	pt.x = mx;
	pt.y = my;

	ClientToScreen( (HWND)getHandle(), &pt );
	ScreenToClient( (HWND)getParent()->getHandle(), &pt );

	mx = pt.x;
	my = pt.y;
}

int	CExpressionToolWorkspace::handleEvent( mxEvent *event )
{
	MDLCACHE_CRITICAL_SECTION_( g_pMDLCache );

	int iret = 0;

	switch ( event->event )
	{
	case mxEvent::MouseDown:
		{
			HWND wnd = (HWND)getParent()->getHandle();
			SetFocus( wnd );
			SetWindowPos( wnd, HWND_TOP, 0, 0, 0, 0, SWP_NOMOVE | SWP_NOSIZE | SWP_SHOWWINDOW);

			{
				int mx = (short)event->x;
				int my = (short)event->y;

				MouseToToolMouse( mx, my, "CExpressionToolWorkspace mousedown" );

				g_pExpressionTool->SetClickedPos( mx, my );
				g_pExpressionTool->SetMouseOverPos( mx, my );
				g_pExpressionTool->DrawMouseOverPos();

			}

			int oldFocus = m_nFocusItem;
			m_nFocusItem = GetItemUnderMouse( (short)event->x, (short)event->y );

			if ( oldFocus != -1 &&
				oldFocus != m_nFocusItem )
			{
				TimelineItem *item = GetItem( oldFocus );
				if ( item )
				{
					item->DrawSelf();
				}
			}
			if ( m_nFocusItem != -1 )
			{
				TimelineItem *item = GetItem( m_nFocusItem );
				if ( item )
				{
					RECT rc;
					item->GetBounds( rc );

					event->x -= rc.left;
					event->y -= rc.top;

					iret = item->handleEvent( event );
				}
			}
			
			iret = 1;
		}
		break;
	case mxEvent::MouseDrag:
	case mxEvent::MouseMove:
		{
			// 
			bool handled = false;

			if ( m_nFocusItem != -1 )
			{
				TimelineItem *item = GetItem( m_nFocusItem );
				if ( item )
				{
					RECT rc;
					item->GetBounds( rc );

					event->x -= rc.left;
					event->y -= rc.top;

					iret = item->handleEvent( event );

					if ( event->event == mxEvent::MouseDrag )
					{
						int mx, my;
						
						item->GetLastMouse( mx, my );
						mx += rc.left;
						my += rc.top;

						MouseToToolMouse( mx, my, "CExpressionToolWorkspace mousedrag" );

						g_pExpressionTool->SetMouseOverPos( mx, my );
						g_pExpressionTool->DrawMouseOverPos();
						handled = true;
					}
				}
			}

			if ( !handled )
			{
				int mx = (short)event->x;
				int my = (short)event->y;

				mx += TRAY_ITEM_INSET;

				MouseToToolMouse( mx, my, "CExpressionToolWorkspace mousemove" );

				g_pExpressionTool->SetMouseOverPos( mx, my );
				g_pExpressionTool->DrawMouseOverPos();
			}
		}
		break;
	case mxEvent::MouseUp:
		{
			// 
			{
				int mx = (short)event->x;
				int my = (short)event->y;

				MouseToToolMouse( mx, my, "CExpressionToolWorkspace mouseup" );

				g_pExpressionTool->SetMouseOverPos( mx, my );
				g_pExpressionTool->DrawMouseOverPos();

			}

			if ( m_nFocusItem != -1 )
			{
				TimelineItem *item = GetItem( m_nFocusItem );
				if ( item )
				{
					RECT rc;
					item->GetBounds( rc );

					event->x -= rc.left;
					event->y -= rc.top;

					iret = item->handleEvent( event );
				}
			}
		}
		break;
	case mxEvent::Size:
		{
			RepositionVSlider();
			LayoutItems();
			iret = 1;
		}
		break;
	case mxEvent::MouseWheeled:
		// Tell parent
		{
			if ( event->modifiers & mxEvent::KeyShift )
			{
				CChoreoScene *scene = g_pChoreoView->GetScene();
				if ( scene )
				{
					int tz = g_pChoreoView->GetTimeZoom( g_pExpressionTool->GetToolName() );

					// Zoom time in  / out
					if ( event->height > 0 )
					{
						g_pChoreoView->SetTimeZoom( g_pExpressionTool->GetToolName(), min( tz + TIME_ZOOM_STEP, MAX_TIME_ZOOM ), false );
					}
					else
					{
						g_pChoreoView->SetTimeZoom( g_pExpressionTool->GetToolName(), min( tz - TIME_ZOOM_STEP, MAX_TIME_ZOOM ), false );
					}
					g_pExpressionTool->RepositionHSlider();
				}
				redraw();
				iret = 1;
				return iret;
			}

			int offset = 0;
			int jump = 50;

			if ( event->height < 0 )
			{
				offset = m_pVertScrollBar->getValue();
				offset += jump;
				offset = min( offset, m_pVertScrollBar->getMaxValue() );
			}
			else
			{
				offset = m_pVertScrollBar->getValue();
				offset -= jump;
				offset = max( offset, m_pVertScrollBar->getMinValue() );
			}

			m_pVertScrollBar->setValue( offset );
			InvalidateRect( (HWND)m_pVertScrollBar->getHandle(), NULL, TRUE );
			m_nTopOffset = offset;
			LayoutItems();
			iret = 1;
		}
		break;
	case mxEvent::Action:
		{
			iret = 1;
			switch ( event->action )
			{
			default:
				iret = 0;
				break;
			case IDC_EXPRESSIONTOOLVSCROLL:
				{
					int offset = 0;
					bool processed = true;

					switch ( event->modifiers )
					{
					case SB_THUMBTRACK:
						offset = event->height;
						break;
					case SB_PAGEUP:
						offset = m_pVertScrollBar->getValue();
						offset -= 100;
						offset = max( offset, m_pVertScrollBar->getMinValue() );
						break;
					case SB_PAGEDOWN:
						offset = m_pVertScrollBar->getValue();
						offset += 100;
						offset = min( offset, m_pVertScrollBar->getMaxValue() );
						break;
					case SB_LINEDOWN:
						offset = m_pVertScrollBar->getValue();
						offset += 10;
						offset = min( offset, m_pVertScrollBar->getMaxValue() );
						break;
					case SB_LINEUP:
						offset = m_pVertScrollBar->getValue();
						offset -= 10;
						offset = max( offset, m_pVertScrollBar->getMinValue() );
						break;
					default:
						processed = false;
						break;
					}
		
					if ( processed )
					{
						m_pVertScrollBar->setValue( offset );
						InvalidateRect( (HWND)m_pVertScrollBar->getHandle(), NULL, TRUE );
						m_nTopOffset = offset;
						LayoutItems();
					}
				}
			}
		}
		break;
	}
	return iret;
}

void CExpressionToolWorkspace::HideTimelines( void )
{
	for ( int i = 0; i < GLOBAL_STUDIO_FLEX_CONTROL_COUNT; i++ )
	{
		TimelineItem *item = GetItem( i );
		Assert( item );
		item->SetVisible( false );
	}

	redraw();
}


TimelineItem *CExpressionToolWorkspace::GetItem( int number )
{
	if ( number < 0 || number >= GLOBAL_STUDIO_FLEX_CONTROL_COUNT )
	{
		return NULL;
	}
	return m_pItems[ number ];
}

TimelineItem *CExpressionToolWorkspace::GetClickedItem( void )
{
	return GetItem( m_nFocusItem );
}

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
void CExpressionToolWorkspace::ClearClickedItem( void )
{
	m_nFocusItem = -1;
}



//-----------------------------------------------------------------------------
// Purpose: 
// Input  : force - force vert scrollbar recomputation	
//-----------------------------------------------------------------------------
void CExpressionToolWorkspace::LayoutItems( bool force /* = false */ )
{
	int x = TRAY_ITEM_INSET;
	int y = - m_nTopOffset;
	int width = w2() - 2 * TRAY_ITEM_INSET - m_nScrollbarHeight;
	int height;

	for ( int i = 0; i < GLOBAL_STUDIO_FLEX_CONTROL_COUNT; i++ )
	{
		TimelineItem *item = GetItem( i );
		if ( !item || !item->GetVisible() )
			continue;

		height = item->GetHeight();

		RECT rcBounds;
		rcBounds.left = x;
		rcBounds.top = y;
		rcBounds.right = x + width;
		rcBounds.bottom = y + height;

		item->SetBounds( rcBounds );
		y += height + m_nItemGap;
	}

	if ( force || ( ComputeVPixelsNeeded() != m_nLastVPixelsNeeded ) )
	{
		RepositionVSlider();
	}

	redraw();
}

int CExpressionToolWorkspace::ComputeVPixelsNeeded( void )
{
	int pixels = 0;

	// Count visible
	int c = 0;
	for ( int i = 0; i < GLOBAL_STUDIO_FLEX_CONTROL_COUNT; i++ )
	{
		TimelineItem *item = GetItem( i );
		if ( !item || !item->GetVisible() )
			continue;

		c += item->GetHeight();
		c += m_nItemGap;
	}

	pixels += c;

	return pixels;
}

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
void CExpressionToolWorkspace::RepositionVSlider( void )
{
	int pixelsneeded = ComputeVPixelsNeeded();

	if ( pixelsneeded <= ( h2() ))
	{
		m_pVertScrollBar->setVisible( false );
		m_nTopOffset = 0;
	}
	else
	{
		m_pVertScrollBar->setVisible( true );
	}

	m_pVertScrollBar->setBounds( 
		w2() - m_nScrollbarHeight, 
		0, 
		m_nScrollbarHeight, 
		h2() );

	m_nTopOffset = max( 0, m_nTopOffset );
	m_nTopOffset = min( pixelsneeded, m_nTopOffset );

	m_pVertScrollBar->setRange( 0, pixelsneeded );
	m_pVertScrollBar->setValue( m_nTopOffset );
	m_pVertScrollBar->setPagesize( h2() );

	m_nLastVPixelsNeeded = pixelsneeded;
}

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
void CExpressionToolWorkspace::DisableAllExcept( void )
{
	TimelineItem *keepExpanded = GetClickedItem();
	if ( !keepExpanded )
		return;

	g_pChoreoView->SetDirty( true );
	g_pChoreoView->PushUndo( "Disable All Except" );

	for ( int i = 0; i < GLOBAL_STUDIO_FLEX_CONTROL_COUNT; i++ )
	{
		TimelineItem *item = GetItem( i );

		item->SetActive( item == keepExpanded ? true : false );
	}

	LayoutItems();
	g_pChoreoView->PushRedo( "Disable All Except" );
}

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
void CExpressionToolWorkspace::EnableValid( void )
{
	g_pChoreoView->SetDirty( true );
	g_pChoreoView->PushUndo( "Enable Valid" );
	for ( int i = 0; i < GLOBAL_STUDIO_FLEX_CONTROL_COUNT; i++ )
	{
		TimelineItem *item = GetItem( i );

		item->SetActive( item->IsValid() );
	}

	LayoutItems();
	g_pChoreoView->PushRedo( "Enable Valid" );
}

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
void CExpressionToolWorkspace::CollapseAll( TimelineItem *keepExpanded )
{
	for ( int i = 0; i < GLOBAL_STUDIO_FLEX_CONTROL_COUNT; i++ )
	{
		TimelineItem *item = GetItem( i );

		item->SetCollapsed( item == keepExpanded ? false : true );
	}

	LayoutItems();
}

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
void CExpressionToolWorkspace::ExpandAll( void )
{
	for ( int i = 0; i < GLOBAL_STUDIO_FLEX_CONTROL_COUNT; i++ )
	{
		TimelineItem *item = GetItem( i );
		item->SetCollapsed( false );
	}

	LayoutItems();
}

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
void CExpressionToolWorkspace::OnSnapAll()
{
	g_pChoreoView->SetDirty( true );
	g_pChoreoView->PushUndo( "Snap All" );

	for ( int i = 0; i < GLOBAL_STUDIO_FLEX_CONTROL_COUNT; i++ )
	{
		TimelineItem *item = GetItem( i );
		item->SnapAll();
	}

	g_pChoreoView->PushRedo( "Snap All" );
	redraw();
}

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
void CExpressionToolWorkspace::OnDeleteColumn()
{
	float t = g_pExpressionTool->GetTimeForClickedPos();

	float snapped = FacePoser_SnapTime( t );
	int scenefps = FacePoser_GetSceneFPS();

	if ( scenefps <= 0 )
	{
		Con_Printf( "Can't delete column, scene fps is <= 0 (%i)\n", scenefps );
		return;
	}

	int clickedframe = ( int ) ( scenefps * snapped + 0.5f );

	// One half of 1/fps on each side
	float epsilon = epsilon = 0.5f / (float)scenefps;

	CInputParams params;
	memset( &params, 0, sizeof( params ) );
	strcpy( params.m_szDialogTitle, "Delete Column" );
	strcpy( params.m_szPrompt, "Frame(s) to delete [e.g., 82 or 81-91 ]:" );
	Q_snprintf( params.m_szInputText, sizeof( params.m_szInputText ), "%i", clickedframe );

	if ( !InputProperties( &params ) )
		return;

	int deleteframestart;
	int deleteframeend;

	char *sep = Q_strstr( params.m_szInputText, "-" );
	if ( sep )
	{
		*sep = 0;
		deleteframestart = atoi( params.m_szInputText );
		deleteframeend = atoi( sep + 1 );
		deleteframeend = max( deleteframestart, deleteframeend );
	}
	else
	{
		deleteframestart = atoi( params.m_szInputText );
		deleteframeend = deleteframestart;
	}

	float start, end;

	start = (float)deleteframestart / (float)scenefps;
	end = (float)deleteframeend / (float)scenefps;

	g_pChoreoView->SetDirty( true );
	g_pChoreoView->PushUndo( "Delete Column" );

	for ( int i = 0; i < GLOBAL_STUDIO_FLEX_CONTROL_COUNT; i++ )
	{
		TimelineItem *item = GetItem( i );
		item->DeletePoints( start - epsilon, end + epsilon );
	}

	g_pChoreoView->PushRedo( "Delete Column" );
	redraw();
}

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
void CExpressionToolWorkspace::ExpandValid( void )
{
	for ( int i = 0; i < GLOBAL_STUDIO_FLEX_CONTROL_COUNT; i++ )
	{
		TimelineItem *item = GetItem( i );
		bool valid = item->IsValid();
		item->SetCollapsed( !valid );
	}

	LayoutItems();
}

//-----------------------------------------------------------------------------
// Purpose: 
// Output : int
//-----------------------------------------------------------------------------
int CExpressionToolWorkspace::CountSelectedSamples( void )
{
	int c = 0;
	for ( int i = 0; i < GLOBAL_STUDIO_FLEX_CONTROL_COUNT; i++ )
	{
		TimelineItem *item = GetItem( i );
		Assert( item );
		item->CountSelected();
		c += item->GetNumSelected();
	}
	return c;
}

void CExpressionToolWorkspace::MoveSelectedSamples( float dfdx, float dfdy, bool snap )
{
	int selecteditems = CountSelectedSamples();
	if ( !selecteditems )
		return;

	CChoreoEvent *e = g_pExpressionTool->GetSafeEvent();
	if ( !e )
		return;

	float eventduration = e->GetDuration();

	for ( int controller = 0; controller < GLOBAL_STUDIO_FLEX_CONTROL_COUNT; controller++ )
	{
		TimelineItem *item = GetItem( controller );
		if ( !item )
			continue;

		CFlexAnimationTrack *track = item->GetSafeTrack();
		if ( !track )
			continue;

		// If the track is a combo type track, then move any underlying selected samples, too
		for ( int edittype = 0; edittype <= ( track->IsComboType() ? 1 : 0 ); edittype++ )
		{
			for ( int i = 0; i < (int)track->GetNumSamples( edittype ); i++ )
			{
				CExpressionSample *sample = track->GetSample( i, edittype );
				if ( !sample || !sample->selected )
					continue;

				sample->time += dfdx;
				sample->time = clamp( sample->time, 0.0f, eventduration );

				if ( snap )
				{
					sample->time = FacePoser_SnapTime( sample->time );
				}

				sample->value -= dfdy;
				sample->value = clamp( sample->value, 0.0f, 1.0f );
			}
		}
				
		track->Resort();

		item->DrawSelf();
	}
}

void CExpressionToolWorkspace::DeleteSelectedSamples( void )
{
	int i, t;

	int selecteditems = CountSelectedSamples();
	if ( !selecteditems )
		return;

	g_pChoreoView->SetDirty( true );
	g_pChoreoView->PushUndo( "Delete points" );

	for ( int controller = 0; controller < GLOBAL_STUDIO_FLEX_CONTROL_COUNT; controller++ )
	{
		TimelineItem *item = GetItem( controller );
		if ( !item )
			continue;

		CFlexAnimationTrack *track = item->GetSafeTrack();
		if ( !track )
			continue;

		for ( t = 0; t < 2; t++ )
		{
			for ( i = track->GetNumSamples( t ) - 1; i >= 0 ; i-- )
			{
				CExpressionSample *sample = track->GetSample( i, t );
				if ( !sample->selected )
					continue;

				track->RemoveSample( i, t );
			}
		}

		item->DrawSelf();
	}

	g_pChoreoView->PushRedo( "Delete points" );
}

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
void CExpressionToolWorkspace::DeselectAll( void )
{
	int i, t;

	int selecteditems = CountSelectedSamples();
	if ( !selecteditems )
		return;

	for ( int controller = 0; controller < GLOBAL_STUDIO_FLEX_CONTROL_COUNT; controller++ )
	{
		TimelineItem *item = GetItem( controller );
		if ( !item )
			continue;

		CFlexAnimationTrack *track = item->GetSafeTrack();
		if ( !track )
			continue;

		for ( t = 0; t < 2; t++ )
		{
			for ( i = track->GetNumSamples( t ) - 1; i >= 0 ; i-- )
			{
				CExpressionSample *sample = track->GetSample( i, t );
				sample->selected = false;
			}
		}

		item->DrawSelf();
	}
}

void CExpressionToolWorkspace::SelectPoints( float start, float end )
{
	int i, t;

	for ( int controller = 0; controller < GLOBAL_STUDIO_FLEX_CONTROL_COUNT; controller++ )
	{
		TimelineItem *item = GetItem( controller );
		if ( !item )
			continue;

		CFlexAnimationTrack *track = item->GetSafeTrack();
		if ( !track )
			continue;

		for ( t = 0; t < 2; t++ )
		{
			for ( i = track->GetNumSamples( t ) - 1; i >= 0 ; i-- )
			{
				CExpressionSample *sample = track->GetSample( i, t );
				bool inrange = ( sample->time >= start && sample->time <= end );
				sample->selected = inrange;
			}
		}

		item->DrawSelf();
	}
}

ExpressionTool::ExpressionTool( mxWindow *parent )
: IFacePoserToolWindow( "ExpressionTool", "Flex Animation" ), mxWindow( parent, 0, 0, 0, 0 )
{
	m_bSuppressLayout = false;

	SetAutoProcess( true );

	m_pWorkspace = new CExpressionToolWorkspace( this );

	m_nFocusEventGlobalID = -1;

	m_flScrub			= 0.0f;
	m_flScrubTarget		= 0.0f;
	m_nDragType			= DRAGTYPE_NONE;

	m_nClickedX			= 0;
	m_nClickedY			= 0;

	m_hPrevCursor		= 0;
	
	m_nStartX			= 0;
	m_nStartY			= 0;

	m_nMinX				= 0;
	m_nMaxX				= 0;
	m_bUseBounds		= false;

	m_pLastEvent		= NULL;

	m_nMousePos[ 0 ] = m_nMousePos[ 1 ] = 0;

	m_flSelection[ 0 ] = m_flSelection[ 1 ] = 0.0f;
	m_bSelectionActive = false;

	m_bLayoutIsValid = false;
	m_flPixelsPerSecond = 500.0f;

	m_flLastDuration = 0.0f;
	m_nScrollbarHeight	= 12;
	m_flLeftOffset = 0.0f;
	m_nLastHPixelsNeeded = -1;
	m_pHorzScrollBar = new mxScrollbar( this, 0, 0, 18, 100, IDC_FLEXHSCROLL, mxScrollbar::Horizontal );
	m_pHorzScrollBar->setVisible( false );

	m_bInSetEvent = false;
	m_flScrubberTimeOffset = 0.0f;
}

ExpressionTool::~ExpressionTool( void )
{
}

void ExpressionTool::DoTrackLookup( CChoreoEvent *event )
{
	if ( !event || !models->GetActiveStudioModel() )
		return;

	//if ( event->GetTrackLookupSet() )
	//	return;

	// Force recompute
	SetEvent( event );
}

#pragma optimize( "g", off )

void ExpressionTool::SetEvent( CChoreoEvent *event )
{
	if ( m_bInSetEvent )
		return;

	m_bInSetEvent = true;

	if ( event == m_pLastEvent )
	{
		if ( event )
		{
			float dur = event->GetDuration();
			if ( dur != m_flLastDuration )
			{
				m_flLastDuration = dur;
				m_nLastHPixelsNeeded = -1;
				m_flLeftOffset = 0.0f;
				InvalidateLayout();
			}

			m_nFocusEventGlobalID = event->GetGlobalID();
		}
		m_bInSetEvent = false;
		return;
	}

	m_pLastEvent = event;

	m_pWorkspace->HideTimelines();

	m_nFocusEventGlobalID = -1;
	if ( event )
	{
		m_nFocusEventGlobalID = event->GetGlobalID();

		if ( models->GetActiveStudioModel() )
		{
			CStudioHdr *hdr = models->GetActiveStudioModel()->GetStudioHdr();
			if ( hdr )
			{
				// Force re-lookup
				event->SetTrackLookupSet( false );
				
				SetupFlexControllerTracks( hdr, event );

				int itemCount = 0;

				for ( int i = 0; i < event->GetNumFlexAnimationTracks(); i++ )
				{
					CFlexAnimationTrack *track = event->GetFlexAnimationTrack( i );
					Assert( track );
					if ( !track )
						continue;

					TimelineItem *item = m_pWorkspace->GetItem( itemCount++ );
					item->SetExpressionInfo( track, track->GetFlexControllerIndex( 0 ) );
					item->SetCollapsed( track->GetNumSamples( 0 ) <= 0 );
					item->SetVisible( true );
				}

				m_pWorkspace->LayoutItems( true );
			}
		}
	}

	DeselectAll();
	
	if ( event )
	{
		m_flLastDuration = event->GetDuration();
	}
	else
	{
		m_flLastDuration = 0.0f;
	}

	m_flLeftOffset = 0.0f;
	m_nLastHPixelsNeeded = -1;
	InvalidateLayout();

	m_bInSetEvent = false;
}

#pragma optimize( "g", on )

//-----------------------------------------------------------------------------
// Purpose: 
// Output : Returns true on success, false on failure.
//-----------------------------------------------------------------------------
bool ExpressionTool::HasCopyData( void )
{
	return ( m_CopyData[0].Size() != 0 ) ? true : false;
}

//-----------------------------------------------------------------------------
// Purpose: 
// Input  : *source - 
//-----------------------------------------------------------------------------
void ExpressionTool::Copy( CFlexAnimationTrack *source )
{
	for ( int t = 0; t < 2; t++ )
	{
		m_CopyData[ t ].RemoveAll();

		if ( t == 0 || source->IsComboType() )
		{
			for ( int i = 0 ; i < source->GetNumSamples( t ); i++ )
			{
				CExpressionSample *s = source->GetSample( i, t );
				m_CopyData[ t ].AddToTail( *s );
			}
		}
	}
}

//-----------------------------------------------------------------------------
// Purpose: 
// Input  : *destination - 
//-----------------------------------------------------------------------------
void ExpressionTool::Paste( CFlexAnimationTrack *destination )
{
	g_pChoreoView->SetDirty( true );
	g_pChoreoView->PushUndo( "Paste" );

	destination->Clear();

	for ( int t = 0; t < 2; t++ )
	{
		for ( int i = 0; i < m_CopyData[ t ].Size() ; i++ )
		{
			CExpressionSample *s = &m_CopyData[ t ][ i ];

			if ( t == 0 || destination->IsComboType() )
			{
				destination->AddSample( s->time, s->value, t );
			}
		}

		destination->Resort( t );
	}
	g_pChoreoView->PushRedo( "Paste" );
}

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
CChoreoEvent *ExpressionTool::GetSafeEvent( void )
{
	if ( m_nFocusEventGlobalID == -1 )
		return NULL;

	if ( !g_pChoreoView )
		return NULL;

	CChoreoScene *scene = g_pChoreoView->GetScene();
	if ( !scene )
		return NULL;

	// look to see if it's focused any any event
	for ( int i = 0; i < scene->GetNumEvents() ; i++ )
	{
		CChoreoEvent *e = scene->GetEvent( i );
		if ( !e || e->GetType() != CChoreoEvent::FLEXANIMATION )
			continue;

		if ( e->GetGlobalID() == m_nFocusEventGlobalID )
		{
			DoTrackLookup( e );
			return e;
		}
	}

	return NULL;
}


//-----------------------------------------------------------------------------
// Purpose: 
// Input  : rcHandle - 
//-----------------------------------------------------------------------------
void ExpressionTool::GetScrubHandleRect( RECT& rcHandle, bool clipped )
{
	float pixel = 0.0f;
	if ( m_pWorkspace->w2() > 0 )
	{
		pixel = GetPixelForTimeValue( m_flScrub );
		if  ( clipped )
		{
			pixel = clamp( pixel, SCRUBBER_HANDLE_WIDTH/2, w2() - SCRUBBER_HANDLE_WIDTH/2 );
		}
	}

	rcHandle.left = pixel-SCRUBBER_HANDLE_WIDTH/2;
	rcHandle.right = pixel + SCRUBBER_HANDLE_WIDTH/2;
	rcHandle.top = 2 + GetCaptionHeight();
	rcHandle.bottom = rcHandle.top + SCRUBBER_HANDLE_HEIGHT;
}

//-----------------------------------------------------------------------------
// Purpose: 
// Input  : drawHelper - 
//			rcHandle - 
//-----------------------------------------------------------------------------
void ExpressionTool::DrawScrubHandle( CChoreoWidgetDrawHelper& drawHelper, RECT& rcHandle )
{
	HBRUSH br = CreateSolidBrush( RGB( 0, 150, 100 ) );

	COLORREF areaBorder = RGB( 230, 230, 220 );

	drawHelper.DrawColoredLine( areaBorder,
		PS_SOLID, 1, 0, rcHandle.top, w2(), rcHandle.top );
	drawHelper.DrawColoredLine( areaBorder,
		PS_SOLID, 1, 0, rcHandle.bottom, w2(), rcHandle.bottom );

	drawHelper.DrawFilledRect( br, rcHandle );

	// 
	char sz[ 32 ];
	sprintf( sz, "%.3f", m_flScrub );

	CChoreoEvent *ev = GetSafeEvent();
	if ( ev )
	{
		float st, ed;
		st = ev->GetStartTime();
		ed = ev->GetEndTime();

		float dt = ed - st;
		if ( dt > 0.0f )
		{
			sprintf( sz, "%.3f", st + m_flScrub );
		}
	}

	int len = drawHelper.CalcTextWidth( "Arial", 9, 500, sz );

	RECT rcText = rcHandle;

	int textw = rcText.right - rcText.left;

	rcText.left += ( textw - len ) / 2;

	drawHelper.DrawColoredText( "Arial", 9, 500, RGB( 255, 255, 255 ), rcText, sz );

	DeleteObject( br );
}

//-----------------------------------------------------------------------------
// Purpose: 
// Input  : *event - 
// Output : Returns true on success, false on failure.
//-----------------------------------------------------------------------------
bool ExpressionTool::IsMouseOverScrubHandle( mxEvent *event )
{
	RECT rcHandle;
	GetScrubHandleRect( rcHandle, true );
	InflateRect( &rcHandle, 2, 2 );

	POINT pt;
	pt.x = (short)event->x;
	pt.y = (short)event->y;
	if ( PtInRect( &rcHandle, pt ) )
	{
		return true;
	}
	return false;
}

//-----------------------------------------------------------------------------
// Purpose: 
// Output : Returns true on success, false on failure.
//-----------------------------------------------------------------------------
bool ExpressionTool::IsProcessing( void )
{
	if ( !GetSafeEvent() )
		return false;

	if ( m_flScrub != m_flScrubTarget )
		return true;

	return false;
}

bool ExpressionTool::IsScrubbing( void ) const
{
	bool scrubbing = ( m_nDragType == DRAGTYPE_SCRUBBER ) ? true : false;
	return scrubbing;
}

void ExpressionTool::Think( float dt )
{
	CChoreoEvent *event = GetSafeEvent();
	if ( !event )
		return;

	bool scrubbing = IsScrubbing();

	ScrubThink( dt, scrubbing );
}

void ExpressionTool::SetScrubTime( float t )
{
	m_flScrub = t;
	CChoreoEvent *e = GetSafeEvent();
	if ( e )
	{
		float realtime = e->GetStartTime() + m_flScrub;

		g_pChoreoView->SetScrubTime( realtime );
		g_pChoreoView->DrawScrubHandle();
	}
}

void ExpressionTool::SetScrubTargetTime( float t )
{
	m_flScrubTarget = t;
	CChoreoEvent *e = GetSafeEvent();
	if ( e )
	{
		float realtime = e->GetStartTime() + m_flScrubTarget;

		g_pChoreoView->SetScrubTargetTime( realtime );
	}
}

//-----------------------------------------------------------------------------
// Purpose: 
// Input  : dt - 
//-----------------------------------------------------------------------------
void ExpressionTool::ScrubThink( float dt, bool scrubbing )
{
	CChoreoEvent *event = GetSafeEvent();
	if ( !event )
		return;

	if ( m_flScrubTarget == m_flScrub && !scrubbing )
		return;

	float d = m_flScrubTarget - m_flScrub;
	int sign = d > 0.0f ? 1 : -1;

	float maxmove = dt;

	if ( sign > 0 )
	{
		if ( d < maxmove )
		{
			SetScrubTime( m_flScrubTarget );
		}
		else
		{
			SetScrubTime( m_flScrub + maxmove );
		}
	}
	else
	{
		if ( -d < maxmove )
		{
			SetScrubTime( m_flScrubTarget );
		}
		else
		{
			SetScrubTime( m_flScrub - maxmove );
		}
	}

	if ( scrubbing )
	{
		g_pMatSysWindow->Frame();
	}
}

void ExpressionTool::redraw()
{
	if ( !ToolCanDraw() )
		return;

	CChoreoWidgetDrawHelper drawHelper( this );
	HandleToolRedraw( drawHelper );

	COLORREF areaBorder = RGB( 230, 230, 220 );

	RECT rcSelection;
	GetWorkspaceRect( rcSelection );

	drawHelper.DrawColoredLine( areaBorder,
		PS_SOLID, 1, 0, rcSelection.top, w2(), rcSelection.top );
	drawHelper.DrawColoredLine( areaBorder,
		PS_SOLID, 1, 0, rcSelection.bottom, w2(), rcSelection.bottom );

	if ( m_bSelectionActive )
	{
		RECT rcClient;
		drawHelper.GetClientRect( rcClient );

		int left, right;
		left = GetPixelForTimeValue( m_flSelection[ 0 ] );
		right = GetPixelForTimeValue( m_flSelection[ 1 ] );

		rcSelection.left = left;
		rcSelection.right = right;
		rcSelection.bottom = TRAY_HEIGHT;
		
		drawHelper.DrawFilledRect( RGB( 200, 220, 230 ), rcSelection );

		drawHelper.DrawColoredLine( RGB( 100, 100, 255 ), PS_SOLID, 3, rcSelection.left, rcSelection.top, rcSelection.left, rcSelection.bottom );
		drawHelper.DrawColoredLine( RGB( 100, 100, 255 ), PS_SOLID, 3, rcSelection.right, rcSelection.top, rcSelection.right, rcSelection.bottom );

	}

	CChoreoEvent *ev = GetSafeEvent();
	if ( ev )
	{
		RECT rcText;
		drawHelper.GetClientRect( rcText );
		rcText.top += GetCaptionHeight()+1;
		rcText.bottom = rcText.top + 13;
		rcText.left += 5;
		rcText.right -= 5;

		OffsetRect( &rcText, 0, 12 );

		int current, total;

		g_pChoreoView->GetUndoLevels( current, total );
		if ( total > 0 )
		{
			RECT rcUndo = rcText;
			OffsetRect( &rcUndo, 0, 2 );

			drawHelper.DrawColoredText( "Small Fonts", 8, FW_NORMAL, RGB( 0, 100, 0 ), rcUndo,
				"Undo:  %i/%i", current, total );
		}

		rcText.left += 60;
		
		// Found it, write out description
		// 
		drawHelper.DrawColoredText( "Arial", 11, 900, RGB( 200, 150, 100 ), rcText,
			"Event:  %s",
			ev->GetName() );

		OffsetRect( &rcText, 0, 30 );

		rcText.left = 5;

		RECT timeRect = rcText;

		timeRect.right = timeRect.left + 100;

		char sz[ 32 ];

		float st, ed;

		GetStartAndEndTime( st, ed );

		st += ev->GetStartTime();
		ed += ev->GetStartTime();

		Q_snprintf( sz, sizeof( sz ), "%.2f", st );

		drawHelper.DrawColoredText( "Arial", 9, FW_NORMAL, RGB( 0, 0, 0 ), timeRect, sz );

		timeRect = rcText;

		Q_snprintf( sz, sizeof( sz ), "%.2f", ed );

		int textW = drawHelper.CalcTextWidth( "Arial", 9, FW_NORMAL, sz );

		timeRect.right = w2() - 10;
		timeRect.left = timeRect.right - textW;

		drawHelper.DrawColoredText( "Arial", 9, FW_NORMAL, RGB( 0, 0, 0 ), timeRect, sz );
	}

	RECT rcHandle;
	GetScrubHandleRect( rcHandle, true );
	DrawScrubHandle( drawHelper, rcHandle );

	DrawRelativeTags( drawHelper );

	RECT rcPos;
	GetMouseOverPosRect( rcPos );
	DrawMouseOverPos( drawHelper, rcPos );

	DrawEventEnd( drawHelper );
}

//-----------------------------------------------------------------------------
// Purpose: 
// Input  : *tag - 
//-----------------------------------------------------------------------------
bool ExpressionTool::GetTimingTagRect( RECT& rcClient, CChoreoEvent *event, CFlexTimingTag *tag, RECT& rcTag )
{
	rcTag = rcClient;

	int tagx = GetPixelForTimeValue( tag->GetStartTime() - event->GetStartTime() );

	rcTag.top		= rcClient.bottom - 6;
	rcTag.bottom	= rcTag.top + 6;
	rcTag.left		= tagx - 3;
	rcTag.right		= tagx + 3;

	return true;
}

// Get workspace min, max point in terms of tool window
void ExpressionTool::GetWorkspaceLeftRight( int& left, int& right )
{
	POINT pt;
	pt.x = TRAY_ITEM_INSET;
	pt.y = 0;

	ClientToScreen( (HWND)m_pWorkspace->getHandle(), &pt );
	ScreenToClient( (HWND)getHandle(), &pt );

	left = (short)pt.x;

	pt.x = m_pWorkspace->w2() - TRAY_ITEM_INSET - 12;
	pt.y = 0;

	ClientToScreen( (HWND)m_pWorkspace->getHandle(), &pt );
	ScreenToClient( (HWND)getHandle(), &pt );

	right = (short)pt.x;
}

//-----------------------------------------------------------------------------
// Purpose: 
// Input  : mx - 
//			my - 
// Output : CFlexTimingTag
//-----------------------------------------------------------------------------
CFlexTimingTag *ExpressionTool::IsMouseOverTag( int mx, int my )
{
	CChoreoEvent *event = GetSafeEvent();
	if ( !event )
		return NULL;

	RECT rcClient;
	GetClientRect( (HWND)getHandle(), &rcClient );

	int left, right;

	GetWorkspaceLeftRight( left, right );

	rcClient.left	= left;
	rcClient.right	= right;
	rcClient.top	= GetCaptionHeight();
	rcClient.bottom = rcClient.top + TRAY_HEIGHT;

	POINT pt;
	pt.x = mx;
	pt.y = my;

	for ( int i = 0 ; i < event->GetNumTimingTags(); i++ )
	{
		CFlexTimingTag *tag = event->GetTimingTag( i );
		if ( !tag )
			continue;

		RECT rcTag;

		if ( !GetTimingTagRect( rcClient, event, tag, rcTag ) )
			continue;

		if ( !PtInRect( &rcTag, pt ) )
			continue;

		return tag;
	}

	return NULL;
}

//-----------------------------------------------------------------------------
// Purpose: 
// Input  : drawHelper - 
//-----------------------------------------------------------------------------
void ExpressionTool::DrawRelativeTags( CChoreoWidgetDrawHelper& drawHelper )
{
	CChoreoEvent *event = GetSafeEvent();
	if ( !event )
		return;

	float st, ed;
	GetStartAndEndTime( st, ed );

	if ( event->GetDuration() <= 0.0f )
		return;

	CChoreoScene *scene = g_pChoreoView->GetScene();
	if ( !scene )
		return;

	RECT rcClient;
	drawHelper.GetClientRect( rcClient );

	int left, right;

	GetWorkspaceLeftRight( left, right );

	rcClient.top += GetCaptionHeight();

	rcClient.left	= left;
	rcClient.right	= right;

	rcClient.bottom = rcClient.top + TRAY_HEIGHT;

	// Iterate relative tags
	for ( int i = 0; i < scene->GetNumActors(); i++ )
	{
		CChoreoActor *a = scene->GetActor( i );
		if ( !a )
			continue;

		for ( int j = 0; j < a->GetNumChannels(); j++ )
		{
			CChoreoChannel *c = a->GetChannel( j );
			if ( !c )
				continue;

			for ( int k = 0 ; k < c->GetNumEvents(); k++ )
			{
				CChoreoEvent *e = c->GetEvent( k );
				if ( !e )
					continue;

				// add each tag to combo box
				for ( int t = 0; t < e->GetNumRelativeTags(); t++ )
				{
					CEventRelativeTag *tag = e->GetRelativeTag( t );
					if ( !tag )
						continue;

					//SendMessage( control, CB_ADDSTRING, 0, (LPARAM)va( "\"%s\" \"%s\"", tag->GetName(), e->GetParameters() ) ); 
					bool clipped;
					int tagx = GetPixelForTimeValue( tag->GetStartTime() - event->GetStartTime(), &clipped );
					if ( clipped )
						continue;

					//drawHelper.DrawColoredLine( RGB( 180, 180, 220 ), PS_SOLID, 1, tagx, rcClient.top, tagx, rcClient.bottom );
					
					RECT rcMark;
					rcMark = rcClient;
					rcMark.top = rcClient.bottom - 6;
					rcMark.left = tagx - 3;
					rcMark.right = tagx + 3;
					
					drawHelper.DrawTriangleMarker( rcMark, RGB( 0, 100, 250 ) );
					
					RECT rcText;
					rcText = rcMark;
					rcText.top -= 10;
					
					int len = drawHelper.CalcTextWidth( "Arial", 9, FW_NORMAL, tag->GetName() );
					rcText.left = tagx - len / 2;
					rcText.right = rcText.left + len + 2;
					
					rcText.bottom = rcText.top + 10;
					
					drawHelper.DrawColoredText( "Arial", 9, FW_NORMAL, RGB( 0, 100, 200 ), rcText, tag->GetName() );

				}
			}
		}
	}

	for ( int t = 0; t < event->GetNumTimingTags(); t++ )
	{
		CFlexTimingTag *tag = event->GetTimingTag( t );
		if ( !tag )
			continue;

		RECT rcMark;

		if ( !GetTimingTagRect( rcClient, event, tag, rcMark ) )
			continue;

		drawHelper.DrawTriangleMarker( rcMark, RGB( 250, 100, 0 ) );
		
		RECT rcText;
		rcText = rcMark;
		rcText.top -= 20;
		
		char text[ 256 ];
		sprintf( text, "%s", tag->GetName() );
		if ( tag->GetLocked() )
		{
			strcat( text, " - locked" );
		}

		int len = drawHelper.CalcTextWidth( "Arial", 9, FW_NORMAL, text );
		rcText.left = ( rcMark.left + rcMark.right ) / 2 - len / 2;
		rcText.right = rcText.left + len + 2;
		
		rcText.bottom = rcText.top + 10;
		
		drawHelper.DrawColoredText( "Arial", 9, FW_NORMAL, RGB( 200, 100, 0 ), rcText, text );

	}
}

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
void ExpressionTool::ShowContextMenu( mxEvent *event, bool include_track_menus )
{
	// Construct main menu
	mxPopupMenu *pop = new mxPopupMenu();

	TimelineItem *item = NULL;
	CFlexAnimationTrack *track = NULL;

	if ( include_track_menus )
	{
		item = m_pWorkspace->GetClickedItem();
		if ( item )
		{
			item->CountSelected();
			track = item->GetSafeTrack();
		}
	}

	int current, total;
	g_pChoreoView->GetUndoLevels( current, total );
	if ( total > 0 )
	{
		if ( current > 0 )
		{
			pop->add( va( "Undo %s", g_pChoreoView->GetUndoDescription() ), IDC_UNDO_FA );
		}
		
		if ( current <= total - 1 )
		{
			pop->add( va( "Redo %s", g_pChoreoView->GetRedoDescription() ), IDC_REDO_FA );
		}
		pop->addSeparator();
	}

	// Create expand menu
	mxPopupMenu *expand = new mxPopupMenu();
	if ( item && track && item->IsCollapsed() )
	{
		expand->add( va( "Track '%s'", track->GetFlexControllerName() ), IDC_TL_EXPAND );
	}
	expand->add( "All tracks", IDC_EXPANDALL );
	expand->add( "Used tracks", IDC_EXPANDVALID );

	pop->addMenu( "Expand", expand );

	mxPopupMenu *collapse = new mxPopupMenu;

	if ( item && track && !item->IsCollapsed() )
	{
		collapse->add( va( "Track '%s'", track->GetFlexControllerName() ), IDC_TL_COLLAPSE );
		collapse->add( va( "All tracks except '%s'", track->GetFlexControllerName() ), IDC_COLLAPSE_ALL_EXCEPT );
	}

	collapse->add( "All tracks", IDC_COLLAPSEALL );

	pop->addMenu( "Collapse", collapse );

	pop->addSeparator();

	pop->add( va( "Enable all valid" ), IDC_ENABLE_ALL_VALID );
	
	if ( item && track )
	{
		if ( item->IsActive() )
		{
			pop->add( va( "Disable '%s'", track->GetFlexControllerName() ), IDC_TL_DISABLE );
		}
		else
		{
			pop->add( va( "Enable '%s'", track->GetFlexControllerName() ), IDC_TL_ENABLE );
		}
		pop->add( va( "Disable all except '%s'", track->GetFlexControllerName() ), IDC_DISABLE_ALL_EXCEPT );

		pop->addSeparator();
		pop->add( "Copy", IDC_TL_COPY );
		if ( HasCopyData() )
		{
			pop->add( "Paste", IDC_TL_PASTE );
		}

		pop->addSeparator();
		if ( item->GetNumSelected() > 0 )
		{
			pop->add( va( "Delete" ), IDC_TL_DELETE );
			pop->add( "Deselect all", IDC_TL_DESELECT );
			pop->add( va( "Scale selected..." ), IDC_FLEX_SCALESAMPLES );
		}
		pop->add( "Select all", IDC_TL_SELECTALL );

		if ( FacePoser_IsSnapping() )
		{
			mxPopupMenu *snap = new mxPopupMenu();

			snap->add( va( "All points" ), IDC_TL_SNAPALL );
			snap->add( va( "All points in '%s'", track->GetFlexControllerName() ), IDC_TL_SNAPPOINTS );
			snap->add( va( "Selected points in '%s'", track->GetFlexControllerName() ), IDC_TL_SNAPSELECTED );

			pop->addSeparator();

			pop->addMenu( "Snap", snap );
		}

		if ( track->IsComboType() )
		{
			pop->addSeparator();

			if ( item->GetEditType() == 0 )
			{
				pop->add( "Edit <left/right>", IDC_TL_EDITLEFTRIGHT );
			}
			else
			{
				pop->add( "Edit <amount>", IDC_TL_EDITNORMAL );
			}
		}

		pop->addSeparator();
		mxPopupMenu *heightMenu = new mxPopupMenu();
		heightMenu->add( va( "Reset '%s'", track->GetFlexControllerName() ) , IDC_ET_RESET_ITEM_SIZE );
		heightMenu->add( "Reset All", IDC_ET_RESET_ALL_ITEM_SIZES );
		pop->addMenu( "Height", heightMenu );

		pop->addSeparator();
		pop->add( "Edge Properties...", IDC_ET_EDGEPROPERTIES );
	}
	pop->addSeparator();

	mxPopupMenu *tagmenu = new mxPopupMenu();

	CFlexTimingTag *tag = IsMouseOverTag( (short)event->x, (short)event->y );
	if ( tag )
	{
		if ( tag->GetLocked() )
		{
			tagmenu->add( va( "Unlock tag '%s'...", tag->GetName() ), IDC_UNLOCK_TIMING_TAG );
		}
		else
		{
			tagmenu->add( va( "Lock tag '%s'...", tag->GetName() ), IDC_LOCK_TIMING_TAG );
		}
		tagmenu->addSeparator();
		tagmenu->add( va( "Delete tag '%s'...", tag->GetName() ), IDC_DELETE_TIMING_TAG );
	}
	else
	{
		tagmenu->add( "Insert...", IDC_INSERT_TIMING_TAG );
	}

	bool bMouseOverSelection = IsMouseOverSelection( (short)event->x, (short)event->y );

	if ( bMouseOverSelection || HasCopiedColumn() )
	{
		mxPopupMenu *selectionMenu = new mxPopupMenu();

		if ( bMouseOverSelection ) 
		{
			selectionMenu->add( "Copy samples", IDC_ET_SELECTION_COPY );
		}

		if ( HasCopiedColumn() )
		{
			selectionMenu->add( "Paste samples", IDC_ET_SELECTION_PASTE );
		}

		if ( bMouseOverSelection )
		{
			selectionMenu->addSeparator();
			selectionMenu->add( "Delete samples", IDC_ET_SELECTION_DELETE );
			selectionMenu->add( "Delete samples and shift remainder", IDC_ET_SELECTION_EXCISE );
		}
		pop->addMenu( "Column", selectionMenu );
	}



	pop->addMenu( "Timing Tags", tagmenu );

	if ( FacePoser_IsSnapping() )
	{
		pop->addSeparator();
		pop->add( "Delete keys by frame", IDC_TL_DELETECOLUMN );
		pop->addSeparator();
	}

	mxPopupMenu *flexmenu = new mxPopupMenu();

	flexmenu->add( "Copy to sliders", IDC_COPY_TO_FLEX );
	flexmenu->add( "Copy from sliders", IDC_COPY_FROM_FLEX );
	pop->addMenu( "Flex", flexmenu );

	pop->add( "Create expression...", IDC_NEW_EXPRESSION_FROM_FLEXANIMATION ); 

	CChoreoEvent *e = GetSafeEvent();
	if ( e )
	{
		mxPopupMenu *importexport = new mxPopupMenu();

		importexport->add( "Export flex animation...", IDC_EXPORT_FA );
		importexport->add( "Import flex animation...", IDC_IMPORT_FA );

		pop->addMenu( "Import/Export", importexport );
	}

	pop->add( va( "Change scale..." ), IDC_FLEX_CHANGESCALE );

	mxPopupMenu *sortmenu = new mxPopupMenu();
	sortmenu->add( "Sort by name", IDC_ET_SORT_BY_NAME );
	sortmenu->add( "Sort by used", IDC_ET_SORT_BY_USED );

	pop->addMenu( "Sort", sortmenu );

	pop->popup( this, (short)event->x, (short)event->y );
}

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
void ExpressionTool::DrawFocusRect( void )
{
	HDC dc = GetDC( NULL );

	for ( int i = 0; i < m_FocusRects.Size(); i++ )
	{
		RECT rc = m_FocusRects[ i ].m_rcFocus;

		::DrawFocusRect( dc, &rc );
	}

	ReleaseDC( NULL, dc );
}

void ExpressionTool::SetClickedPos( int x, int y )
{
	m_nClickedX = x;
	m_nClickedY = y;
}

float ExpressionTool::GetTimeForClickedPos( void )
{
	CChoreoEvent *e = GetSafeEvent();
	if ( !e )
		return 0.0f;

	float t = GetTimeValueForMouse( m_nClickedX );

	// Get spline intensity for controller
	float faketime = e->GetStartTime() + t;
	return faketime;
}

//-----------------------------------------------------------------------------
// Purpose: 
// Input  : dragtype - 
//			startx - 
//			cursor - 
//-----------------------------------------------------------------------------
void ExpressionTool::StartDragging( int dragtype, int startx, int starty, HCURSOR cursor )
{
	m_nDragType = dragtype;
	m_nStartX	= startx;
	m_nLastX	= startx;
	m_nStartY	= starty;
	m_nLastY	= starty;
	
	if ( m_hPrevCursor )
	{
		SetCursor( m_hPrevCursor );
		m_hPrevCursor = NULL;
	}
	m_hPrevCursor = SetCursor( cursor );

	m_FocusRects.Purge();

	RECT rc;
	GetWorkspaceRect( rc );

	RECT rcStart;
	rcStart.left = startx;
	rcStart.right = startx;

	bool addrect = true;
	switch ( dragtype )
	{
	default:
	case DRAGTYPE_SCRUBBER:
		{
			RECT rcScrub;
			GetScrubHandleRect( rcScrub, true );

			rcStart = rcScrub;
			rcStart.left = ( rcScrub.left + rcScrub.right ) / 2;
			rcStart.right = rcStart.left;
			rcStart.top = rcScrub.bottom;

			rcStart.bottom = h2();
		}
		break;
	case DRAGTYPE_FLEXTIMINGTAG:
		{
			rcStart.top = rc.top;
			rcStart.bottom = h2();
		}
		break;
	case DRAGTYPE_SELECTSAMPLES:
		{
			float st = GetTimeValueForMouse( startx );
			rcStart.left = GetPixelForTimeValue( st );
			rcStart.right = rcStart.left;

			m_nStartX	= rcStart.left;
			m_nLastX	= rcStart.left;
		}
	case DRAGTYPE_MOVESELECTIONSTART:
	case DRAGTYPE_MOVESELECTIONEND:
		{
			rcStart.top = rc.top;
			rcStart.bottom = rc.bottom;
		}
		break;
	case DRAGTYPE_MOVESELECTION:
		{
			rcStart.top = rc.top;
			rcStart.bottom = rc.bottom;

			// Compute left/right pixels for selection
			rcStart.left = GetPixelForTimeValue( m_flSelection[ 0 ] );
			rcStart.right = GetPixelForTimeValue( m_flSelection[ 1 ] );
		}
		break;
	}


	if ( addrect )
	{
		AddFocusRect( rcStart );
	}
	
	DrawFocusRect();
}

void ExpressionTool::OnMouseMove( mxEvent *event )
{
	int mx = (short)event->x;
	int my = (short)event->y;

	event->x = (short)mx;

	if ( m_nDragType != DRAGTYPE_NONE )
	{
		DrawFocusRect();

		for ( int i = 0; i < m_FocusRects.Size(); i++ )
		{
			CFocusRect *f = &m_FocusRects[ i ];
			f->m_rcFocus = f->m_rcOrig;

			switch ( m_nDragType )
			{
			default:
				{
					OffsetRect( &f->m_rcFocus, ( (short)event->x - m_nStartX ),	0 );
				}
				break;
			case DRAGTYPE_SELECTSAMPLES:
				{
					float st = GetTimeValueForMouse( mx );
					int snapx = GetPixelForTimeValue( st );
					f->m_rcFocus.left = min( snapx, m_nStartX );
					f->m_rcFocus.right = max( snapx, m_nStartY );

					POINT offset;
					offset.x = 0;
					offset.y = 0;
					ClientToScreen( (HWND)getHandle(), &offset );
					OffsetRect( &f->m_rcFocus, offset.x, 0 );

				}
				break;
			}
		}

		DrawFocusRect();
	}
	else
	{
		if ( m_hPrevCursor )
		{
			SetCursor( m_hPrevCursor );
			m_hPrevCursor = NULL;
		}

		if ( IsMouseOverScrubHandle( event ) )
		{
			m_hPrevCursor = SetCursor( LoadCursor( NULL, IDC_SIZEWE ) );
		}
		else if ( IsMouseOverTag( mx, my ) )
		{
			m_hPrevCursor = SetCursor( LoadCursor( NULL, IDC_SIZEWE ) );
		}
		else if ( IsMouseOverSelection( (short)event->x, (short)event->y ) )
		{
			if ( IsMouseOverSelectionStartEdge( event ) )
			{
				m_hPrevCursor = SetCursor( LoadCursor( NULL, IDC_SIZEWE ) );
			}
			else if ( IsMouseOverSelectionEndEdge( event ) )
			{
				m_hPrevCursor = SetCursor( LoadCursor( NULL, IDC_SIZEWE ) );
			}
			else
			{
				if ( event->modifiers & mxEvent::KeyShift )
				{
					m_hPrevCursor = SetCursor( LoadCursor( NULL, IDC_SIZEALL ) );
				}
			}
		}
	}

	switch ( m_nDragType )
	{
	default:
		break;
	case DRAGTYPE_FLEXTIMINGTAG:
		{
			ApplyBounds( mx, my );
		}
		break;
	case DRAGTYPE_SCRUBBER:
		{
			ApplyBounds( mx, my );
			if ( w2() > 0 )
			{
				float t = GetTimeValueForMouse( mx );
				t += m_flScrubberTimeOffset;
				ForceScrubPosition( t );
			}
		}
		break;
	}

	m_nLastX = (short)event->x;
	m_nLastY = (short)event->y;
}

int	ExpressionTool::handleEvent( mxEvent *event )
{
	MDLCACHE_CRITICAL_SECTION_( g_pMDLCache );

	int iret = 0;

	if ( HandleToolEvent( event ) )
	{
		return iret;
	}

	switch ( event->event )
	{
	case mxEvent::Size:
		{
			int w, h;
			w = event->width;
			h = event->height;

			m_pWorkspace->setBounds( 5, TRAY_HEIGHT + GetCaptionHeight(), w - 10, h - ( TRAY_HEIGHT + 5 + GetCaptionHeight() ) - m_nScrollbarHeight );

			m_nLastHPixelsNeeded = 0;
			InvalidateLayout();

			iret = 1;
		}
		break;
	case mxEvent::MouseWheeled:
		{
			CChoreoScene *scene = g_pChoreoView->GetScene();
			if ( scene )
			{
				int tz = g_pChoreoView->GetTimeZoom( GetToolName() );
				bool shiftdown = ( event->modifiers & mxEvent::KeyShift ) ? true : false;
				int stepMultipiler = shiftdown ? 5 : 1;

				// Zoom time in  / out
				if ( event->height > 0 )
				{
					tz = min( tz + TIME_ZOOM_STEP * stepMultipiler, MAX_TIME_ZOOM );
				}
				else
				{
					tz = max( tz - TIME_ZOOM_STEP * stepMultipiler, TIME_ZOOM_STEP );
				}

				g_pChoreoView->SetPreservedTimeZoom( this, tz );
			}
			//RepositionHSlider();
			m_pWorkspace->redraw();
			redraw();
			iret = 1;
		}
		break;
	case mxEvent::MouseDown:
		{
//			bool ctrldown = ( event->modifiers & mxEvent::KeyCtrl ) ? true : false;
			bool shiftdown = ( event->modifiers & mxEvent::KeyShift ) ? true : false;

			iret = 1;

			int mx = (short)event->x;
			int my = (short)event->y;

			SetClickedPos( mx, my );

			SetMouseOverPos( mx, my );
			DrawMouseOverPos();

			if ( event->buttons & mxEvent::MouseRightButton )
			{
				ShowContextMenu( event, false );
				return iret;
			}
		
			if ( m_nDragType == DRAGTYPE_NONE )
			{
				if ( IsMouseOverScrubHandle( event ) )
				{
					if ( w2() > 0 )
					{
						float t = GetTimeValueForMouse( (short)event->x );
						m_flScrubberTimeOffset = m_flScrub - t;
						float maxoffset = 0.5f * (float)SCRUBBER_HANDLE_WIDTH / GetPixelsPerSecond();
						m_flScrubberTimeOffset = clamp( m_flScrubberTimeOffset, -maxoffset, maxoffset );
						t += m_flScrubberTimeOffset;
						ForceScrubPosition( t );
					}

					StartDragging( DRAGTYPE_SCRUBBER, m_nClickedX, m_nClickedY, LoadCursor( NULL, IDC_SIZEWE ) );
				}
				else if ( IsMouseOverTag( m_nClickedX, m_nClickedY ) )
				{
					StartDragging( DRAGTYPE_FLEXTIMINGTAG, m_nClickedX, m_nClickedY, LoadCursor( NULL, IDC_SIZEWE ) );
				}
				else if ( IsMouseOverPoints( m_nClickedX, m_nClickedY ) )
				{
					if ( !m_bSelectionActive )
					{
						StartDragging( DRAGTYPE_SELECTSAMPLES, m_nClickedX, m_nClickedY, LoadCursor( NULL, IDC_SIZEWE ) );
					}
					else
					{
						// Either move, move edge if ctrl key is held, or deselect
						if ( IsMouseOverSelection( m_nClickedX,m_nClickedY ) )
						{
							if ( IsMouseOverSelectionStartEdge( event ) )
							{
								StartDragging( DRAGTYPE_MOVESELECTIONSTART, m_nClickedX, m_nClickedY, LoadCursor( NULL, IDC_SIZEWE ) );
							}
							else if ( IsMouseOverSelectionEndEdge( event ) )
							{
								StartDragging( DRAGTYPE_MOVESELECTIONEND, m_nClickedX, m_nClickedY, LoadCursor( NULL, IDC_SIZEWE ) );
							}
							else
							{
								if ( shiftdown )
								{
									StartDragging( DRAGTYPE_MOVESELECTION, m_nClickedX, m_nClickedY, LoadCursor( NULL, IDC_SIZEALL ) );
								}
							}
						}
						else
						{
							m_bSelectionActive = false;
							redraw();
							return iret;
						}
					}
				}
				else
				{
					if ( w2() > 0 )
					{
						float t = GetTimeValueForMouse( (short)event->x );

						SetScrubTargetTime( t );
					}
				}

				CalcBounds( m_nDragType );
			}
		}
		break;
	case mxEvent::MouseDrag:
	case mxEvent::MouseMove:
		{
			int mx = (short)event->x;
			int my = (short)event->y;

			SetMouseOverPos( mx, my );
			DrawMouseOverPos();

			OnMouseMove( event );

			iret = 1;
		}
		break;
	case mxEvent::MouseUp:
		{
			if ( event->buttons & mxEvent::MouseRightButton )
			{
				return 1;
			}

			int mx = (short)event->x;
			int my = (short)event->y;

			if ( m_nDragType != DRAGTYPE_NONE )
			{
				DrawFocusRect();
			}

			if ( m_hPrevCursor )
			{
				SetCursor( m_hPrevCursor );
				m_hPrevCursor = 0;
			}

			switch ( m_nDragType )
			{
			case DRAGTYPE_NONE:
				break;
			case DRAGTYPE_SELECTSAMPLES:
				FinishSelect( m_nStartX, mx );
				break;
			case DRAGTYPE_MOVESELECTION:
				FinishMoveSelection( m_nStartX, mx );
				break;
			case DRAGTYPE_MOVESELECTIONSTART:
				FinishMoveSelectionStart( m_nStartX, mx );
				break;
			case DRAGTYPE_MOVESELECTIONEND:
				FinishMoveSelectionEnd( m_nStartX, mx );
				break;
			case DRAGTYPE_SCRUBBER:
				{
					ApplyBounds( mx, my );

//					int dx = mx - m_nStartX;
//					int dy = my = m_nStartY;

					if ( w2() > 0 )
					{
						float t = GetTimeValueForMouse( (short)event->x );
						t += m_flScrubberTimeOffset;
						m_flScrubberTimeOffset = 0.0f;
						ForceScrubPosition( t );
					}
				}
				break;
			case DRAGTYPE_FLEXTIMINGTAG:
				{
					ApplyBounds( mx, my );

//					int dx = mx - m_nStartX;
//					int dy = my = m_nStartY;

					// Compute dx, dy and apply to sections
					//Con_Printf( "dx == %i\n", dx );
					CFlexTimingTag *tag = IsMouseOverTag( m_nStartX, m_nStartY );
					CChoreoEvent *ev = GetSafeEvent();
					if ( tag && g_pChoreoView && ev && ev->GetDuration() )
					{
						float t = GetTimeValueForMouse( mx );

						float percent = t / ev->GetDuration();

						g_pChoreoView->SetDirty( true );

						g_pChoreoView->PushUndo( "Move Timing Tag" );

						if ( tag->GetLocked() )
						{
							// Resample all control points on right/left
							//  of locked tags all the way to the next lock or edge
							ResampleControlPoints( tag, percent );
						}

						tag->SetPercentage( percent );

						g_pChoreoView->PushRedo( "Move Timing Tag" );
					}

					LayoutItems( true );
					redraw();
				}
				break;
			}

			m_nDragType = DRAGTYPE_NONE;

			SetMouseOverPos( mx, my );
			DrawMouseOverPos();

			iret = 1;
		}
		break;
	case mxEvent::Action:
		{
			iret = 1;
			switch ( event->action )
			{
			default:
				iret = 0;
				break;
			case IDC_ET_RESET_ITEM_SIZE:
				OnResetItemSize();
				break;
			case IDC_ET_RESET_ALL_ITEM_SIZES:
				OnResetAllItemSizes();
				break;
			case IDC_ET_SELECTION_DELETE:
				OnDeleteSelection( false );
				break;
			case IDC_ET_SELECTION_EXCISE:
				OnDeleteSelection( true );
				break;
			case IDC_ET_SELECTION_COPY:
				OnCopyColumn();
				break;
			case IDC_ET_SELECTION_PASTE:
				OnPasteColumn();
				break;
			case IDC_ET_SORT_BY_USED:
				OnSortByUsed();
				break;
			case IDC_ET_SORT_BY_NAME:
				OnSortByName();
				break;
			case IDC_EXPORT_FA:
				OnExportFlexAnimation();
				break;
			case IDC_IMPORT_FA:
				OnImportFlexAnimation();
				break;
			case IDC_LOCK_TIMING_TAG:
				LockTimingTag();
				break;
			case IDC_UNLOCK_TIMING_TAG:
				UnlockTimingTag();
				break;
			case IDC_DELETE_TIMING_TAG:
				DeleteFlexTimingTag( m_nClickedX, m_nClickedY );
				break;
			case IDC_INSERT_TIMING_TAG:
				AddFlexTimingTag( m_nClickedX );
				break;
			case IDC_EXPANDALL:
				m_pWorkspace->ExpandAll();
				break;
			case IDC_COLLAPSEALL:
				m_pWorkspace->CollapseAll( NULL );
				break;
			case IDC_COLLAPSE_ALL_EXCEPT:
				m_pWorkspace->CollapseAll( m_pWorkspace->GetClickedItem() );
				break;
			case IDC_EXPANDVALID:
				m_pWorkspace->ExpandValid();
				break;
			case IDC_COPY_TO_FLEX:
				OnCopyToFlex( true );
				break;
			case IDC_COPY_FROM_FLEX:
				OnCopyFromFlex( false );
				break;
			case IDC_NEW_EXPRESSION_FROM_FLEXANIMATION:
				OnNewExpression();
				break;
			case IDC_UNDO_FA:
				OnUndo();
				break;
			case IDC_REDO_FA:
				OnRedo();
				break;
			case IDC_TL_EDITNORMAL:
				{
					TimelineItem *item = m_pWorkspace->GetClickedItem();
					if ( item )
					{
						item->SetEditType( 0 );
						item->DrawSelf();
					}
				}
				break;
			case IDC_TL_EDITLEFTRIGHT:
				{
					TimelineItem *item = m_pWorkspace->GetClickedItem();
					if ( item )
					{
						item->SetEditType( 1 );
						item->DrawSelf();
					}
				}
				break;
			case IDC_TL_EXPAND:
				{
					TimelineItem *item = m_pWorkspace->GetClickedItem();
					if ( item )
					{
						item->SetCollapsed( false );
					}
					LayoutItems();
				}
				break;
			case IDC_TL_COLLAPSE:
				{
					TimelineItem *item = m_pWorkspace->GetClickedItem();
					if ( item )
					{
						item->SetCollapsed( true );
					}
					LayoutItems();
				}
				break;
			case IDC_TL_ENABLE:
				{
					TimelineItem *item = m_pWorkspace->GetClickedItem();
					if ( item )
					{
						g_pChoreoView->SetDirty( true );
						g_pChoreoView->PushUndo( "Enable item" );

						item->SetActive( true );

						g_pChoreoView->PushRedo( "Enable item" );

						item->DrawSelf();
					}
				}
				break;
			case IDC_TL_DISABLE:
				{
					TimelineItem *item = m_pWorkspace->GetClickedItem();
					if ( item )
					{
						g_pChoreoView->SetDirty( true );
						g_pChoreoView->PushUndo( "Disable item" );

						item->SetActive( false );

						g_pChoreoView->PushRedo( "Disable item" );

						item->DrawSelf();
					}
				}
				break;
			case IDC_TL_COPY:
				{
					TimelineItem *item = m_pWorkspace->GetClickedItem();
					if ( item )
					{
						item->Copy();
					}
				}
				break;
			case IDC_TL_PASTE:
				{
					TimelineItem *item = m_pWorkspace->GetClickedItem();
					if ( item )
					{
						item->Paste();
						item->DrawSelf();
					}
				}
				break;
			case IDC_TL_DELETE:
				{
					TimelineItem *item = m_pWorkspace->GetClickedItem();
					if ( item )
					{
						item->Delete();
						item->DrawSelf();
					}
				}
				break;
			case IDC_TL_DESELECT:
				{
					TimelineItem *item = m_pWorkspace->GetClickedItem();
					if ( item )
					{
						item->DeselectAll();
						item->DrawSelf();
					}
				}
				break;
			case IDC_TL_SELECTALL:
				{
					TimelineItem *item = m_pWorkspace->GetClickedItem();
					if ( item )
					{
						item->SelectAll();
						item->DrawSelf();
					}
				}
				break;
			case IDC_DISABLE_ALL_EXCEPT:
				{
					m_pWorkspace->DisableAllExcept();
				}
				break;
			case IDC_ENABLE_ALL_VALID:
				{
					m_pWorkspace->EnableValid();
				}
				break;
			case IDC_TL_SNAPSELECTED:
				{
					TimelineItem *item = m_pWorkspace->GetClickedItem();
					if ( item )
					{
						g_pChoreoView->SetDirty( true );
						g_pChoreoView->PushUndo( "Snap Selected" );

						item->SnapSelected();

						g_pChoreoView->PushRedo( "Snap Selected" );
						item->DrawSelf();
					}
				}
				break;
			case IDC_TL_SNAPPOINTS:
				{
					TimelineItem *item = m_pWorkspace->GetClickedItem();
					if ( item )
					{
						g_pChoreoView->SetDirty( true );
						g_pChoreoView->PushUndo( "Snap Item" );

						item->SnapAll();

						g_pChoreoView->PushRedo( "Snap Item" );
						item->DrawSelf();
					}
				}
				break;
			case IDC_TL_DELETECOLUMN:
				{
					m_pWorkspace->OnDeleteColumn();
				}
				break;
			case IDC_TL_SNAPALL:
				{
					m_pWorkspace->OnSnapAll();
				}
				break;
			case IDC_FLEXHSCROLL:
				{
					int offset = 0;
					bool processed = true;

					switch ( event->modifiers )
					{
					case SB_THUMBTRACK:
						offset = event->height;
						break;
					case SB_PAGEUP:
						offset = m_pHorzScrollBar->getValue();
						offset -= 20;
						offset = max( offset, m_pHorzScrollBar->getMinValue() );
						break;
					case SB_PAGEDOWN:
						offset = m_pHorzScrollBar->getValue();
						offset += 20;
						offset = min( offset, m_pHorzScrollBar->getMaxValue() );
						break;
					case SB_LINEUP:
						offset = m_pHorzScrollBar->getValue();
						offset -= 10;
						offset = max( offset, m_pHorzScrollBar->getMinValue() );
						break;
					case SB_LINEDOWN:
						offset = m_pHorzScrollBar->getValue();
						offset += 10;
						offset = min( offset, m_pHorzScrollBar->getMaxValue() );
						break;
					default:
						processed = false;
						break;
					}

					if ( processed )
					{
						MoveTimeSliderToPos( offset );
					}
				}
				break;
			case IDC_FLEX_CHANGESCALE:
				{
					OnChangeScale();
				}
				break;
			case IDC_FLEX_SCALESAMPLES:
				{
					OnScaleSamples();
				}
				break;
			case IDC_ET_EDGEPROPERTIES:
				{
					OnEdgeProperties();
				}
				break;
			}
		}
		break;
	case mxEvent::KeyDown:
	case mxEvent::KeyUp:
		{
			TimelineItem *item = m_pWorkspace->GetClickedItem();
			if ( item )
			{
				iret = item->handleEvent( event );					
			}

			if ( !iret )
			{
				switch ( event->key )
				{
				default:
					break;
				case VK_ESCAPE:
					{
						DeselectAll();
						iret = 1;
					}
					break;
				}
			}
		}
		break;
	}
	return iret;
}

//-----------------------------------------------------------------------------
// Purpose: 
// Input  : false - 
//-----------------------------------------------------------------------------
void ExpressionTool::LayoutItems( bool force /*= false*/ )
{
	m_pWorkspace->LayoutItems( force );
}

//-----------------------------------------------------------------------------
// Purpose: 
// Input  : *event - 
//-----------------------------------------------------------------------------
void ExpressionTool::AddFlexTimingTag( int mx )
{
	Assert( g_pChoreoView );

	CChoreoEvent *event = GetSafeEvent();
	if ( !event )
		return;

	if ( event->GetType() != CChoreoEvent::FLEXANIMATION )
	{
		Con_ErrorPrintf( "Timing Tag:  Can only tag FLEXANIMATION events\n" );
		return;
	}

	CInputParams params;
	memset( &params, 0, sizeof( params ) );

	strcpy( params.m_szDialogTitle, "Event Tag Name" );
	strcpy( params.m_szPrompt, "Name:" );

	strcpy( params.m_szInputText, "" );

	if ( !InputProperties( &params ) )
		return;

	if ( strlen( params.m_szInputText ) <= 0 )
	{
		Con_ErrorPrintf( "Timing Tag Name:  No name entered!\n" );
		return;
	}
	
	// Convert click to frac
	float t = GetTimeValueForMouse( mx );
	float frac = 0.0f;
	if ( event->GetDuration() )
	{
		frac = t / event->GetDuration();
		frac = clamp( frac, 0.0f, 1.0f );
	}

	g_pChoreoView->SetDirty( true );

	g_pChoreoView->PushUndo( "Add Timing Tag" );

	event->AddTimingTag( params.m_szInputText, frac, true );

	g_pChoreoView->PushRedo( "Add Timing Tag" );

	// Redraw this window
	m_pWorkspace->redraw();
	redraw();
}

void ExpressionTool::DeleteFlexTimingTag( int mx, int my )
{
	Assert( g_pChoreoView );

	CChoreoEvent *event = GetSafeEvent();
	if ( !event )
		return;

	CFlexTimingTag *tag = IsMouseOverTag( mx, my );
	if ( !tag )
		return;
	
	g_pChoreoView->SetDirty( true );

	g_pChoreoView->PushUndo( "Delete Timing Tag" );

	event->RemoveTimingTag( tag->GetName() );

	g_pChoreoView->PushRedo( "Delete Timing Tag" );

	LayoutItems( true );
	// Redraw this window
	redraw();

}

void ExpressionTool::LockTimingTag( void )
{
	Assert( g_pChoreoView );

	CChoreoEvent *event = GetSafeEvent();
	if ( !event )
		return;

	CFlexTimingTag *tag = IsMouseOverTag( m_nClickedX, m_nClickedY );
	if ( !tag )
		return;

	if ( tag->GetLocked() )
		return;

	g_pChoreoView->SetDirty( true );

	g_pChoreoView->PushUndo( "Lock Timing Tag" );

	tag->SetLocked( true );

	g_pChoreoView->PushRedo( "Lock Timing Tag" );

	redraw();
}

void ExpressionTool::UnlockTimingTag( void )
{
	Assert( g_pChoreoView );

	CChoreoEvent *event = GetSafeEvent();
	if ( !event )
		return;

	CFlexTimingTag *tag = IsMouseOverTag( m_nClickedX, m_nClickedY );
	if ( !tag )
		return;

	if ( !tag->GetLocked() )
		return;

	g_pChoreoView->SetDirty( true );

	g_pChoreoView->PushUndo( "Unlock Timing Tag" );

	tag->SetLocked( false );

	g_pChoreoView->PushRedo( "Unlock Timing Tag" );

	redraw();
}

void ExpressionTool::ApplyBounds( int& mx, int& my )
{
	if ( !m_bUseBounds )
		return;

	mx = clamp( mx, m_nMinX, m_nMaxX );
}

void ExpressionTool::CalcBounds( int movetype )
{
	switch ( movetype )
	{
	default:
	case DRAGTYPE_NONE:
		m_bUseBounds = false;
		m_nMinX = 0;
		m_nMaxX = 0;
		break;
	case DRAGTYPE_SCRUBBER:
		m_bUseBounds = true;
		m_nMinX = 0;
		m_nMaxX = w2();
		break;
	case DRAGTYPE_FLEXTIMINGTAG:
		{
			m_bUseBounds = true;

			int left, right;
			GetWorkspaceLeftRight( left, right );

			m_nMinX = left;
			m_nMaxX = right;

			RECT rcClient;
			rcClient.left = left;
			rcClient.right = right;
			rcClient.top = 0;
			rcClient.bottom = TRAY_HEIGHT;

			CFlexTimingTag *tag = IsMouseOverTag( m_nStartX, m_nStartY );
			if ( tag && 
				tag->GetOwner() )
			{
				CChoreoEvent *e = tag->GetOwner();
				
				float st = e->GetStartTime();
				float ed = e->GetEndTime();
				
				if ( ed > st )
				{
					
					
					// Find previous tag, if any
					CFlexTimingTag *prev = NULL;
					CFlexTimingTag *next = NULL;
					
					for ( int i = 0; i < e->GetNumTimingTags(); i++ )
					{
						CFlexTimingTag *test = e->GetTimingTag( i );
						if ( test != tag )
							continue;
						
						// Found it
						if ( i > 0 )
						{
							prev = e->GetTimingTag( i - 1 );
						}
						
						if ( i + 1  < e->GetNumTimingTags() )
						{
							next = e->GetTimingTag( i + 1 );
						}
						break;
					}
					
					if ( prev )
					{
						// Compute x pixel of prev tag
						float frac = ( prev->GetStartTime() - st ) / ( ed - st );
						if ( frac >= 0.0f && frac <= 1.0f )
						{
							int tagx = rcClient.left + (int)( frac * (float)( rcClient.right - rcClient.left ) );
							
							m_nMinX = max( m_nMinX, tagx + 5 );
						}
					}
					
					if ( next )
					{
						// Compute x pixel of next tag
						float frac = ( next->GetStartTime() - st ) / ( ed - st );
						if ( frac >= 0.0f && frac <= 1.0f )
						{
							int tagx = rcClient.left + (int)( frac * (float)( rcClient.right - rcClient.left ) );
							m_nMaxX = min( m_nMaxX, tagx - 5 );
						}
					}
				}

			}
		}
		break;
	}
}

//-----------------------------------------------------------------------------
// Purpose: 
// Input  : *tag - 
//			newposition - 
//-----------------------------------------------------------------------------
void ExpressionTool::ResampleControlPoints( CFlexTimingTag *tag, float newposition )
{
	CChoreoEvent *e = tag->GetOwner();
	if ( !e )
		return;

	float duration = e->GetDuration();

	float leftedge = 0.0f;
	float rightedge = duration;
	
	// Find neighboring locked tags, if any
	CFlexTimingTag *prev = NULL;
	CFlexTimingTag *next = NULL;
	
	int i;
	for ( i = 0; i < e->GetNumTimingTags(); i++ )
	{
		CFlexTimingTag *test = e->GetTimingTag( i );
		if ( test != tag )
			continue;
		
		// Found it
		if ( i > 0 )
		{
			int i1 = i - 1;
			while ( 1 )
			{
				if ( i1 < 0 )
				{
					prev = NULL;
					break;
				}

				prev = e->GetTimingTag( i1 );
				if ( prev->GetLocked() )
					break;

				i1--;
			}
		}
		
		if ( i + 1  < e->GetNumTimingTags() )
		{
			int i1 = i + 1;
			while ( 1 )
			{
				if ( i1 >= e->GetNumTimingTags() )
				{
					next = NULL;
					break;
				}

				next = e->GetTimingTag( i1 );
				if ( next->GetLocked() )
					break;

				i1++;
			}
		}
		break;
	}

	if ( prev )
	{
		leftedge = prev->GetPercentage() * duration;
	}

	if ( next )
	{
		rightedge = next->GetPercentage() * duration;
	}

	// Now, using the tags old position as a pivot, rescale intervening
	//  sample points based on size delta of new vs old range
	float oldpivot = tag->GetPercentage() * duration;
	float newpivot = newposition * duration;

	float oldleftrange = oldpivot - leftedge;
	float oldrightrange = rightedge - oldpivot;

	float newleftrange = newpivot - leftedge;
	float newrightrange = rightedge - newpivot;

	if ( oldleftrange <= 0.0f ||
		 oldrightrange <= 0.0f ||
		 newleftrange <= 0.0f ||
		 newrightrange <= 0.0f )
	{
		Con_Printf( "Range problem!!! avoiding division by zero\n" );
		return;
	}
		 
	for ( i = 0 ; i < e->GetNumFlexAnimationTracks(); i++ )
	{
		CFlexAnimationTrack *track = e->GetFlexAnimationTrack( i );
		if ( !track )
			continue;

		for ( int t = 0; t < ( track->IsComboType() ? 2 : 1 ); t++ )
		{
			for ( int j = 0; j < track->GetNumSamples( t ); j++ )
			{
				CExpressionSample *s = track->GetSample( j, t );
				if ( !s )
					continue;

				float oldtime = s->time;

				// In old range?
				if ( oldtime < leftedge )
					continue;
				if ( oldtime > rightedge )
					continue;

				// In left or right side( tiebreak toward left )
				float newtime = oldtime;

				if ( oldtime <= oldpivot )
				{
					float n = ( oldtime - leftedge ) / oldleftrange;
					newtime = leftedge + n * newleftrange;
				}
				else
				{
					float n = ( oldtime - oldpivot ) / oldrightrange;
					newtime = newpivot + n * newrightrange;
				}

				//newtime = FacePoser_SnapTime( newtime );

				s->time = newtime;
			}
		}
	}
}

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
void ExpressionTool::OnNewExpression( void )
{
	CChoreoEvent *e = GetSafeEvent();
	if ( !e )
		return;

	CStudioHdr *hdr = models->GetActiveStudioModel()->GetStudioHdr();
	if ( !hdr )
	{
		Con_ErrorPrintf( "ExpressionTool::OnNewExpression:  Can't create new face pose, must load a model first!\n" );
		return;
	}

	CExpClass *active = expressions->GetActiveClass();
	if ( !active )
	{
		Con_ErrorPrintf( "ExpressionTool::OnNewExpression:  Can't create new face pose, must load an expression file first!\n" );
		return;
	}

	g_pExpressionTrayTool->Deselect();

	float t = GetTimeValueForMouse( m_nClickedX );

	// Get spline intensity for controller
	float faketime = e->GetStartTime() + t;

	float settings[ GLOBAL_STUDIO_FLEX_CONTROL_COUNT ];
	float weights[ GLOBAL_STUDIO_FLEX_CONTROL_COUNT ];
	memset( settings, 0, sizeof( settings ) );
	memset( weights, 0, sizeof( settings ) );

	for ( int i = 0 ; i < e->GetNumFlexAnimationTracks(); i++ )
	{
		CFlexAnimationTrack *track = e->GetFlexAnimationTrack( i );
		if ( !track )
			continue;

		// Disabled
		if ( !track->IsTrackActive() )
			continue;

		// Map track flex controller to global name
		if ( track->IsComboType() )
		{
			for ( int side = 0; side < 2; side++ )
			{
				int controller = track->GetFlexControllerIndex( side );
				if ( controller != -1 )
				{
					// Get spline intensity for controller
					float flIntensity = track->GetIntensity( faketime, side );

					settings[ controller ] = flIntensity;
					weights[ controller ] = 1.0f;
				}
			}
		}
		else
		{
			int controller = track->GetFlexControllerIndex( 0 );
			if ( controller != -1 )
			{
				// Get spline intensity for controller
				float flIntensity = track->GetIntensity( faketime, 0 );

				settings[ controller ] = flIntensity;
				weights[ controller ] = 1.0f;
			}
		}
	}

	CExpressionParams params;
	memset( &params, 0, sizeof( params ) );

	strcpy( params.m_szDialogTitle, "Add Expression" );
	strcpy( params.m_szName, "" );
	strcpy( params.m_szDescription, "" );

	if ( !ExpressionProperties( &params ) )
		return;

	if ( ( strlen( params.m_szName ) <= 0 ) ||
		!stricmp( params.m_szName, "unnamed" ) )
	{
		Con_ErrorPrintf( "You must type in a valid name\n" );
		return;
	}

	if ( ( strlen( params.m_szDescription ) <= 0 ) ||
   	   !stricmp( params.m_szDescription, "description" ) )
	{
		Con_ErrorPrintf( "You must type in a valid description\n" );
		return;
	}

	active->AddExpression( params.m_szName, params.m_szDescription, settings, weights, true, true );
}

LocalFlexController_t FindFlexControllerIndexByName( StudioModel *model, char const *searchname )
{
	if ( !model )
		return LocalFlexController_t(-1);

	CStudioHdr *hdr = model->GetStudioHdr();
	if ( !hdr )
		return LocalFlexController_t(-1);

	for ( LocalFlexController_t i = LocalFlexController_t(0); i < hdr->numflexcontrollers(); i++ )
	{
		char const *name = hdr->pFlexcontroller( i )->pszName();
		if ( !name )
			continue;

		if ( strcmp( name, searchname ) )
			continue;

		return i;
	}
	return LocalFlexController_t(-1);
}

void ExpressionTool::OnCopyToFlex( bool isEdited )
{
	// local time in the expression tool for the last mouse click
	float t = GetTimeValueForMouse( m_nClickedX );

	CChoreoEvent *e = GetSafeEvent();
	if ( !e )
		return;

	float scenetime = e->GetStartTime() + t;

	OnCopyToFlex( scenetime, isEdited );

	return;
}


void ExpressionTool::OnCopyToFlex( float scenetime, bool isEdited )
{
	CChoreoEvent *e = GetSafeEvent();
	if ( !e )
		return;

	if ( scenetime < e->GetStartTime() || scenetime > e->GetEndTime() )
		return;

	bool needundo = false;

	float *settings = NULL;
	float *weights = NULL;
	CExpression *exp = NULL;
	CExpClass *active = expressions->GetActiveClass();
	if ( active )
	{
		
		int index = active->GetSelectedExpression();
		if ( index != -1 )
		{
			exp = active->GetExpression( index );
			if ( exp )
			{
				needundo = true;
				settings = exp->GetSettings();
				weights = exp->GetWeights();
			}
		}
	}

	if ( needundo && exp )
	{
		exp->PushUndoInformation();
		active->SetDirty( true );
	}

	g_pFlexPanel->ResetSliders( false, true );

	StudioModel *model = models->GetActiveStudioModel();

	for ( int i = 0 ; i < e->GetNumFlexAnimationTracks(); i++ )
	{
		CFlexAnimationTrack *track = e->GetFlexAnimationTrack( i );
		if ( !track )
			continue;

		// Disabled
		if ( !track->IsTrackActive() )
			continue;

		// Map track flex controller to global name
		for ( int side = 0; side < 1 + track->IsComboType(); side++ )
		{
			int controller = track->GetFlexControllerIndex( side );
			if ( controller != -1 )
			{
				// Get spline intensity for controller
				float flIntensity = track->GetIntensity( scenetime, side );

				g_pFlexPanel->SetSlider( controller, flIntensity );
				g_pFlexPanel->SetInfluence( controller, 1.0f );
				g_pFlexPanel->SetEdited( controller, isEdited );
				if( model )
				{
					LocalFlexController_t raw = track->GetRawFlexControllerIndex( side );
					if ( raw != LocalFlexController_t(-1) )
					{
						model->SetFlexController( raw, flIntensity );
					}
				}
				if ( settings && weights )
				{
					settings[ controller ] = flIntensity;
					weights[ controller ] = 1.0f;
				}
			}
		}
	}

	if ( needundo && exp )
	{
		exp->PushRedoInformation();
	}
}

void ExpressionTool::OnCopyFromFlex( bool isEdited )
{
	// local time in the expression tool for the last mouse click
	float t = GetTimeValueForMouse( m_nClickedX );

	CChoreoEvent *e = GetSafeEvent();
	if ( !e )
		return;

	float scenetime = e->GetStartTime() + t;

	OnCopyFromFlex( scenetime, isEdited );

	return;
}

void ExpressionTool::OnSetSingleKeyFromFlex( char const *sliderName )
{
	CChoreoEvent *e = GetSafeEvent();
	if ( !e || !e->GetDuration() )
		return;

	float scenetime = g_pChoreoView->GetScene()->GetTime();
	
	if ( scenetime < e->GetStartTime() || scenetime > e->GetEndTime() )
		return;

	scenetime = FacePoser_SnapTime( scenetime );

	float relativetime = scenetime - e->GetStartTime();

	// Get spline intensity for controller

	float				setting;
	float				influence;
	float				minvalue, maxvalue;

	g_pChoreoView->SetDirty( true );
	g_pChoreoView->PushUndo( "Set Single Key" );

	for (int j = 0; j < GLOBAL_STUDIO_FLEX_CONTROL_COUNT; j++)
	{
		if ( !g_pFlexPanel->IsValidSlider( j ) )
			continue;

		if ( Q_stricmp( g_pFlexPanel->getLabel(), sliderName ) )
			continue;

		setting			= g_pFlexPanel->GetSliderRawValue( j );
		influence		= g_pFlexPanel->GetInfluence( j );

		// g_pFlexPanel->SetEdited( j, isEdited );

		g_pFlexPanel->GetSliderRange( j, minvalue, maxvalue );

		bool found = false;
		for ( int i = 0 ; i < e->GetNumFlexAnimationTracks() && !found; i++ )
		{
			CFlexAnimationTrack *track = e->GetFlexAnimationTrack( i );
			if ( !track )
				continue;

			for ( int side = 0; side < 1 + track->IsComboType(); side++ )
			{
				if ( track->GetFlexControllerIndex( side ) != j )
					continue;

				float normalized = setting;
				if ( side == 0 )
				{
					if ( minvalue != maxvalue )
					{
						normalized = ( setting - minvalue ) / ( maxvalue - minvalue );
					}
					if (track->IsInverted())
					{
						normalized = 1.0 - normalized;
					}
				}

				found = true;

				int nSampleCount = track->GetNumSamples( side );

				int j = 0;
				for ( ; j < nSampleCount; ++j )
				{
					CExpressionSample *s = track->GetSample( j, side );
					if ( s->time == relativetime )
						break;
				}

				if ( j >= nSampleCount )
				{
					track->AddSample( relativetime, normalized, side );
					track->Resort( side );
				}
				else
				{
					CExpressionSample *s = track->GetSample( j, side );
					s->value = normalized;
				}
				
				track->SetTrackActive( true );

				break;
			}
		}
	}

	g_pChoreoView->PushRedo( "Set Single Key" );

	m_pWorkspace->redraw();
	redraw();
}

void ExpressionTool::OnCopyFromFlex( float scenetime, bool isEdited )
{
	CChoreoEvent *e = GetSafeEvent();
	if ( !e || !e->GetDuration() )
		return;

	if ( scenetime < e->GetStartTime() || scenetime > e->GetEndTime() )
		return;

	scenetime = FacePoser_SnapTime( scenetime );

	float relativetime = scenetime - e->GetStartTime();

	// Get spline intensity for controller

	float				setting;
	float				influence;
	float				minvalue, maxvalue;

	g_pChoreoView->SetDirty( true );
	g_pChoreoView->PushUndo( "Copy from Flex" );

	for (int j = 0; j < GLOBAL_STUDIO_FLEX_CONTROL_COUNT; j++)
	{
		if ( !g_pFlexPanel->IsValidSlider( j ) )
			continue;

		setting			= g_pFlexPanel->GetSliderRawValue( j );
		//setting = g_pFlexPanel->GetSlider( j );
		influence		= g_pFlexPanel->GetInfluence( j );

		g_pFlexPanel->SetEdited( j, isEdited );

		g_pFlexPanel->GetSliderRange( j, minvalue, maxvalue );

		// Found it
		if ( !influence )
		{
			continue;
		}

		bool found = false;
		for ( int i = 0 ; i < e->GetNumFlexAnimationTracks() && !found; i++ )
		{
			CFlexAnimationTrack *track = e->GetFlexAnimationTrack( i );
			if ( !track )
				continue;

			for ( int side = 0; side < 1 + track->IsComboType(); side++ )
			{
				if ( track->GetFlexControllerIndex( side ) != j )
					continue;

				float normalized = setting;
				if ( side == 0 )
				{
					if ( minvalue != maxvalue )
					{
						normalized = ( setting - minvalue ) / ( maxvalue - minvalue );
					}
					if (track->IsInverted())
					{
						normalized = 1.0 - normalized;
					}
				}

				found = true;

				track->AddSample( relativetime, normalized, side );
				track->Resort( side );
				track->SetTrackActive( true );

				break;
			}
		}
	}

	g_pChoreoView->PushRedo( "Copy from Flex" );

	m_pWorkspace->redraw();
	redraw();
}

bool ExpressionTool::SetFlexAnimationTrackFromExpression( int mx, int my, CExpClass *cl, CExpression *exp )
{
	CChoreoEvent *e = GetSafeEvent();
	if ( !e | !e->GetDuration() )
	{
		return false;
	}

	if ( !exp )
	{
		return false;
	}

	// Convert screen to client
	POINT pt;
	pt.x = mx;
	pt.y = my;

	ScreenToClient( (HWND)getHandle(), &pt );

	if ( pt.x < 0 || pt.y < 0 )
	{
		return false;
	}

	if ( pt.x > w2() || pt.y > h2() )
	{
		return false;
	}

	float t = GetTimeValueForMouse( (short)pt.x );
	
	// Get spline intensity for controller
	// Get spline intensity for controller
	float relativetime = t;
	float faketime = e->GetStartTime() + relativetime;

	faketime = FacePoser_SnapTime( faketime );

	float *settings = exp->GetSettings();
	float *influence = exp->GetWeights();

	if ( !settings || !influence )
		return false;

	g_pChoreoView->SetDirty( true );
	g_pChoreoView->PushUndo( "Copy from Expression" );

	for ( int i = 0 ; i < e->GetNumFlexAnimationTracks(); i++ )
	{
		CFlexAnimationTrack *track = e->GetFlexAnimationTrack( i );
		if ( !track )
			continue;

		if ( track->IsComboType() )
		{
			int left = track->GetFlexControllerIndex( 0 );
			int right = track->GetFlexControllerIndex( 1 );

			float leftval = settings[ left ];
			float leftinfluence = influence[ left ];
			float rightval = settings[ right ];
			float rightinfluence = influence[ right ];

			if ( leftinfluence || rightinfluence )
			{

				//Con_Printf( "%s %i(side %i):  amount %f inf %f\n", track->GetFlexControllerName(), j, side, s, inf );
				
				float mag, leftright;

				if (leftval < rightval)
				{
					mag = rightval;
					leftright = 1.0 - (leftval / rightval) * 0.5;
				}
				else if (leftval > rightval)
				{
					mag = leftval;
					leftright = (rightval / leftval) * 0.5;
				}
				else
				{
					mag = leftval;
					leftright = 0.5;
				}

				track->AddSample( relativetime, mag * leftinfluence, 0 );
				track->AddSample( relativetime, leftright, 1 );

				track->Resort( 0 );
				track->Resort( 1 );

				track->SetTrackActive( true );
			}
		}
		else
		{
			int j = track->GetFlexControllerIndex( 0 );

			float s = settings[ j ];
			float inf = influence[ j ];

			if ( inf )
			{
				track->AddSample( relativetime, s, 0 );

				track->Resort( 0 );

				track->SetTrackActive( true );
			}
		}
	}

	g_pChoreoView->PushRedo( "Copy from Expression" );

	m_pWorkspace->redraw();
	redraw();

	return true;
}

bool ExpressionTool::PaintBackground()
{
	redraw();
	return false;
}

void ExpressionTool::OnExportFlexAnimation( void )
{
	CChoreoEvent *event = GetSafeEvent();
	if ( !event )
		return;

	// Create flexanimations dir
	CreatePath( "flexanimations/foo" );

	char fafilename[ 512 ];
	if ( !FacePoser_ShowSaveFileNameDialog( fafilename, sizeof( fafilename ), "flexanimations", "*.vfa" ) )
	{
		return;
	}

	Q_DefaultExtension( fafilename, ".vfa", sizeof( fafilename ) );

	Con_Printf( "Exporting events to %s\n", fafilename );

	CUtlBuffer buf( 0, 0, CUtlBuffer::TEXT_BUFFER );

	CChoreoScene::FileSaveFlexAnimations( buf, 0, event );

	// Write it out baby
	FileHandle_t fh = filesystem->Open( fafilename, "wt" );
	if (fh)
	{
		filesystem->Write( buf.Base(), buf.TellPut(), fh );
		filesystem->Close(fh);
	}
	else
	{
		Con_Printf( "Unable to write file %s!!!\n", fafilename );
	}
}

void ExpressionTool::OnImportFlexAnimation( void )
{
	CChoreoEvent *event = GetSafeEvent();
	if ( !event )
		return;

	char fafilename[ 512 ];
	if ( !FacePoser_ShowOpenFileNameDialog( fafilename, sizeof( fafilename ), "flexanimations", "*.vfa" ) )
	{
		return;
	}

	if ( !filesystem->FileExists( fafilename ) )
		return;

	char fullpath[ 512 ];
	filesystem->RelativePathToFullPath( fafilename, "MOD", fullpath, sizeof( fullpath ) );

	LoadScriptFile( (char *)fullpath );

	tokenprocessor->GetToken( true );
	if ( stricmp( tokenprocessor->CurrentToken(), "flexanimations" ) )
	{
		Con_Printf( "ExpressionTool::OnImportFlexAnimation:  %s, expecting \"flexanimations\"\n",
			fullpath );
	}
	else
	{
		g_pChoreoView->SetDirty( true );
		g_pChoreoView->PushUndo( "Import flex animations" );

		CChoreoScene::ParseFlexAnimations( tokenprocessor, event, true );

		// Force a full reset
		m_pLastEvent = NULL;
		SetEvent( event );

		g_pChoreoView->PushRedo( "Import flex animations" );

		Con_Printf( "Parsed flex animations from %s\n", fullpath );
	}
}

void ExpressionTool::OnUndo( void )
{
	g_pChoreoView->Undo();
}

void ExpressionTool::OnRedo( void )
{
	g_pChoreoView->Redo();
}

void ExpressionTool::ForceScrubPositionFromSceneTime( float scenetime )
{
	CChoreoEvent *e = GetSafeEvent();
	if ( !e || !e->GetDuration() )
		return;

	float t = scenetime - e->GetStartTime();
	m_flScrub = t;
	m_flScrubTarget = t;

	DrawScrubHandles();
}

void ExpressionTool::ForceScrubPosition( float frac )
{
	m_flScrub = frac;
	m_flScrubTarget = frac;
	
	CChoreoEvent *e = GetSafeEvent();
	if ( e )
	{
		float realtime = e->GetStartTime() + frac;

		g_pChoreoView->SetScrubTime( realtime );
		g_pChoreoView->SetScrubTargetTime( realtime );

		g_pChoreoView->DrawScrubHandle();
	}

	DrawScrubHandles();
}

void ExpressionTool::DrawScrubHandles()
{
	RECT rcHandle;
	GetScrubHandleRect( rcHandle, true );

	RECT rcTray = rcHandle;
	rcTray.left = 0;
	rcTray.right = w2();

	CChoreoWidgetDrawHelper drawHelper( this, rcTray );
	DrawScrubHandle( drawHelper, rcHandle );
}

void ExpressionTool::SetMouseOverPos( int x, int y )
{
	m_nMousePos[ 0 ] = x;
	m_nMousePos[ 1 ] = y;
}

void ExpressionTool::GetMouseOverPos( int &x, int& y )
{
	x = m_nMousePos[ 0 ];
	y = m_nMousePos[ 1 ];
}

//-----------------------------------------------------------------------------
// Purpose: 
// Input  : rcPos - 
//-----------------------------------------------------------------------------
void ExpressionTool::GetMouseOverPosRect( RECT& rcPos )
{
	rcPos.top = GetCaptionHeight() + 12;
	rcPos.left = w2() - 200;
	rcPos.right = w2() - 5;
	rcPos.bottom = rcPos.top + 13;
}

//-----------------------------------------------------------------------------
// Purpose: 
// Input  : drawHelper - 
//			rcPos - 
//-----------------------------------------------------------------------------
void ExpressionTool::DrawMouseOverPos( CChoreoWidgetDrawHelper& drawHelper, RECT& rcPos )
{
	// Compute time for pixel x
	float t = GetTimeValueForMouse( m_nMousePos[ 0 ] );
	CChoreoEvent *e = GetSafeEvent();
	if ( !e )
		return;

	t += e->GetStartTime();

	float snapped = FacePoser_SnapTime( t );

	// Found it, write out description
	// 
	char sz[ 128 ];
	if ( t != snapped )
	{
		Q_snprintf( sz, sizeof( sz ), "%s", FacePoser_DescribeSnappedTime( t ) );
	}
	else
	{
		Q_snprintf( sz, sizeof( sz ), "%.3f", t );
	}

	int len = drawHelper.CalcTextWidth( "Arial", 11, 900, sz );

	RECT rcText = rcPos;
	rcText.left = max( rcPos.left, rcPos.right - len );

	drawHelper.DrawColoredText( "Arial", 11, 900, RGB( 255, 50, 70 ), rcText, sz );
}

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
void ExpressionTool::DrawMouseOverPos()
{
	RECT rcPos;
	GetMouseOverPosRect( rcPos );

	CChoreoWidgetDrawHelper drawHelper( this, rcPos );
	DrawMouseOverPos( drawHelper, rcPos );
}

int ExpressionTool::CountSelectedSamples( void )
{
	return m_pWorkspace->CountSelectedSamples();
}

void ExpressionTool::MoveSelectedSamples( float dfdx, float dfdy, bool snap )
{
	m_pWorkspace->MoveSelectedSamples( dfdx, dfdy, snap );
}

void ExpressionTool::DeleteSelectedSamples( void )
{
	m_pWorkspace->DeleteSelectedSamples();
}

void ExpressionTool::DeselectAll( void )
{
	m_pWorkspace->DeselectAll();
	m_bSelectionActive = false;
	redraw();
}

//-----------------------------------------------------------------------------
// Purpose: 
// Input  : start - 
//			end - 
//-----------------------------------------------------------------------------
void ExpressionTool::SelectPoints( float starttime, float endtime )
{
	// Make sure order is correct
	if ( endtime < starttime )
	{
		float temp = endtime;
		endtime = starttime;
		starttime = temp;
	}

	DeselectAll();

	m_flSelection[ 0 ] = starttime;
	m_flSelection[ 1 ] = endtime;
	m_bSelectionActive = true;

	// Select any words that span the selection
	//
	m_pWorkspace->SelectPoints( starttime, endtime );

	redraw();
}

void ExpressionTool::FinishMoveSelection( int startx, int mx )
{
	float start = GetTimeValueForMouse( startx );
	float end = GetTimeValueForMouse( mx );

	float delta = end - start;

	for ( int i = 0; i < 2; i++ )
	{
		m_flSelection[ i ] += delta;
	}

	SelectPoints( m_flSelection[ 0 ], m_flSelection[ 1 ] );

	redraw();
}

void ExpressionTool::FinishMoveSelectionStart( int startx, int mx )
{
	float start = GetTimeValueForMouse( startx );
	float end = GetTimeValueForMouse( mx );

	float delta = end - start;

	m_flSelection[ 0 ] += delta;

	SelectPoints( m_flSelection[ 0 ], m_flSelection[ 1 ] );

	redraw();
}

void ExpressionTool::FinishMoveSelectionEnd( int startx, int mx )
{
	float start = GetTimeValueForMouse( startx );
	float end = GetTimeValueForMouse( mx );

	float delta = end - start;

	m_flSelection[ 1 ] += delta;

	SelectPoints( m_flSelection[ 0 ], m_flSelection[ 1 ] );

	redraw();
}

//-----------------------------------------------------------------------------
// Purpose: 
// Input  : startx - 
//			mx - 
//-----------------------------------------------------------------------------
void ExpressionTool::FinishSelect( int startx, int mx )
{
	// Don't select really small areas
	if ( abs( startx - mx ) < 1 )
		return;

	float start = GetTimeValueForMouse( startx );
	float end = GetTimeValueForMouse( mx );

	SelectPoints( start, end );
}

//-----------------------------------------------------------------------------
// Purpose: 
// Input  : mx - 
//			my - 
// Output : Returns true on success, false on failure.
//-----------------------------------------------------------------------------
bool ExpressionTool::IsMouseOverPoints( int mx, int my )
{
	RECT rc;
	GetWorkspaceRect( rc );

	// Over tag
	if ( my > TRAY_HEIGHT )
		return false;

	if ( my <= 12 + GetCaptionHeight() )
		return false;

	return true;
}

//-----------------------------------------------------------------------------
// Purpose: 
// Input  : mx - 
//			my - 
// Output : Returns true on success, false on failure.
//-----------------------------------------------------------------------------
bool ExpressionTool::IsMouseOverSelection( int mx, int my )
{
	if ( !m_bSelectionActive )
		return false;

	if ( !IsMouseOverPoints( mx, my ) )
		return false;

	float t = GetTimeValueForMouse( mx );

	if ( t >= m_flSelection[ 0 ] &&
		 t <= m_flSelection[ 1 ] )
	{
		return true;
	}

	return false;
}

bool ExpressionTool::IsMouseOverSelectionStartEdge( mxEvent *event )
{
	int mx, my;
	mx = (short)event->x;
	my = (short)event->y;

	if ( !(event->modifiers & mxEvent::KeyCtrl ) )
		return false;

	if ( !IsMouseOverSelection( mx, my ) )
		return false;

	int left;

	left = GetPixelForTimeValue( m_flSelection[ 0 ] );

	if ( abs( left - mx ) <= 2 )
	{
		return true;
	}

	return false;
}

bool ExpressionTool::IsMouseOverSelectionEndEdge( mxEvent *event )
{
	int mx, my;
	mx = (short)event->x;
	my = (short)event->y;

	if ( !(event->modifiers & mxEvent::KeyCtrl ) )
		return false;

	if ( !IsMouseOverSelection( mx, my ) )
		return false;

	int right;

	right = GetPixelForTimeValue( m_flSelection[ 1 ] );

	if ( abs( right - mx ) <= 2 )
	{
		return true;
	}

	return false;
}

//-----------------------------------------------------------------------------
// Purpose: 
// Input  : &rc - 
//-----------------------------------------------------------------------------
void ExpressionTool::GetWorkspaceRect( RECT &rc )
{
	GetClientRect( (HWND)getHandle(), &rc );
	
	rc.top = TRAY_HEIGHT - 17;
	rc.bottom = TRAY_HEIGHT - 1;
	//InflateRect( &rc, -1, -1 );
}

void ExpressionTool::AddFocusRect( RECT& rc )
{
	RECT rcFocus = rc;

	POINT offset;
	offset.x = 0;
	offset.y = 0;
	ClientToScreen( (HWND)getHandle(), &offset );
	OffsetRect( &rcFocus, offset.x, offset.y );

	// Convert to screen space?
	CFocusRect fr;
	fr.m_rcFocus = rcFocus;
	fr.m_rcOrig = rcFocus;

	m_FocusRects.AddToTail( fr );
}

//-----------------------------------------------------------------------------
// Purpose: 
// Output : int
//-----------------------------------------------------------------------------
int ExpressionTool::ComputeHPixelsNeeded( void )
{
	CChoreoEvent *event = GetSafeEvent();
	if ( !event )
		return 0;

	int pixels = 0;
	float maxtime = event->GetDuration();
	pixels = (int)( ( maxtime + 5.0 ) * GetPixelsPerSecond() + 10 );

	return pixels;

}

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
void ExpressionTool::RepositionHSlider( void )
{
	int pixelsneeded = ComputeHPixelsNeeded();

	if ( pixelsneeded <= w2() )
	{
		m_pHorzScrollBar->setVisible( false );
	}
	else
	{
		m_pHorzScrollBar->setVisible( true );
	}
	m_pHorzScrollBar->setBounds( 0, h2() - m_nScrollbarHeight, w2(), m_nScrollbarHeight );

	m_flLeftOffset = max( 0.f, m_flLeftOffset );
	m_flLeftOffset = min( (float)pixelsneeded, m_flLeftOffset );

	m_pHorzScrollBar->setRange( 0, pixelsneeded );
	m_pHorzScrollBar->setValue( m_flLeftOffset );
	m_pHorzScrollBar->setPagesize( w2() );

	m_nLastHPixelsNeeded = pixelsneeded;
}

//-----------------------------------------------------------------------------
// Purpose: 
// Output : float
//-----------------------------------------------------------------------------
float ExpressionTool::GetPixelsPerSecond( void )
{
	return m_flPixelsPerSecond * (float)g_pChoreoView->GetTimeZoom( GetToolName() ) / 100.0f;
}

//-----------------------------------------------------------------------------
// Purpose: 
// Input  : x - 
//-----------------------------------------------------------------------------
void ExpressionTool::MoveTimeSliderToPos( int x )
{
	m_flLeftOffset = x;
	m_pHorzScrollBar->setValue( m_flLeftOffset );
	InvalidateRect( (HWND)m_pHorzScrollBar->getHandle(), NULL, TRUE );
	InvalidateLayout();
}

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
void ExpressionTool::InvalidateLayout( void )
{
	if ( m_bSuppressLayout )
		return;

	if ( ComputeHPixelsNeeded() != m_nLastHPixelsNeeded )
	{
		RepositionHSlider();
	}

	m_bLayoutIsValid = false;
	m_pWorkspace->redraw();
	redraw();
}

//-----------------------------------------------------------------------------
// Purpose: 
// Input  : time - 
//			*clipped - 
// Output : int
//-----------------------------------------------------------------------------
int ExpressionTool::GetPixelForTimeValue( float time, bool *clipped /*=NULL*/ )
{
	int left, right;
	
	GetWorkspaceLeftRight( left, right );

	if ( clipped )
	{
		*clipped = false;
	}

	float st, ed;
	GetStartAndEndTime( st, ed );

	float frac = ( time - st ) / ( ed - st );
	if ( frac < 0.0 || frac > 1.0 )
	{
		if ( clipped )
		{
			*clipped = true;
		}
	}

	int pixel = left + ( int )( frac * (right - left ) );
	return pixel;
}

void ExpressionTool::OnChangeScale( void )
{
	CChoreoScene *scene = g_pChoreoView->GetScene();
	if ( !scene )
	{
		return;
	}

	// Zoom time in  / out
	CInputParams params;
	memset( &params, 0, sizeof( params ) );

	strcpy( params.m_szDialogTitle, "Change Zoom" );
	strcpy( params.m_szPrompt, "New scale (e.g., 2.5x):" );

	Q_snprintf( params.m_szInputText, sizeof( params.m_szInputText ), "%.2f", (float)g_pChoreoView->GetTimeZoom( GetToolName() ) / 100.0f );

	if ( !InputProperties( &params ) )
		return;

	g_pChoreoView->SetTimeZoom( GetToolName(), clamp( (int)( 100.0f * atof( params.m_szInputText ) ), 1, MAX_TIME_ZOOM ), false );

	m_nLastHPixelsNeeded = -1;
	InvalidateLayout();
	Con_Printf( "Zoom factor %i %%\n", g_pChoreoView->GetTimeZoom( GetToolName() ) );
}

//-----------------------------------------------------------------------------
// Purpose: 
// Input  : st - 
//			ed - 
//-----------------------------------------------------------------------------
void ExpressionTool::GetStartAndEndTime( float& st, float& ed )
{
	st = m_flLeftOffset / GetPixelsPerSecond();
	int left, right;
	GetWorkspaceLeftRight( left, right );
	if ( right <= left )
	{
		ed = st;
	}
	else
	{
        ed = st + (float)( right - left ) / GetPixelsPerSecond();
	}
}

//-----------------------------------------------------------------------------
// Purpose: 
// Input  :  - 
// Output : float
//-----------------------------------------------------------------------------
float ExpressionTool::GetEventEndTime()
{
	CChoreoEvent *ev = GetSafeEvent();
	if ( !ev )
		return 1.0f;

	return ev->GetDuration();
}


//-----------------------------------------------------------------------------
// Purpose: 
// Input  : mx - 
//			clip - 
// Output : float
//-----------------------------------------------------------------------------
float ExpressionTool::GetTimeValueForMouse( int mx, bool clip /*=false*/)
{
	int left, right;
	
	GetWorkspaceLeftRight( left, right );

	float st, ed;
	GetStartAndEndTime( st, ed );

	if ( clip )
	{
		if ( mx < 0 )
		{
			return st;
		}
		if ( mx > w2() )
		{
			return ed;
		}
	}

	float frac = (float)( mx - left )  / (float)( right - left );
	return st + frac * ( ed - st );
}

void ExpressionTool::DrawEventEnd( CChoreoWidgetDrawHelper& drawHelper )
{
	CChoreoEvent *e = GetSafeEvent();
	if ( !e )
		return;

	float duration = e->GetDuration();
	if ( !duration )
		return;

	int leftx = GetPixelForTimeValue( duration );
	if ( leftx >= w2() )
		return;

	RECT rcClient;
	drawHelper.GetClientRect( rcClient );

	drawHelper.DrawColoredLine(
		COLOR_CHOREO_ENDTIME, PS_SOLID, 1,
		leftx, rcClient.top + TRAY_HEIGHT, leftx, rcClient.bottom );

}

void ExpressionTool::OnSortByUsed( void )
{
	m_pWorkspace->OnSortByUsed();
}

void ExpressionTool::OnSortByName( void )
{
	m_pWorkspace->OnSortByName();
}

//-----------------------------------------------------------------------------
// Purpose: 
// Input  : *item - 
// Output : Returns true on success, false on failure.
//-----------------------------------------------------------------------------
bool ExpressionTool::IsFocusItem( TimelineItem *item )
{
	return m_pWorkspace->GetClickedItem() == item;
}

//-----------------------------------------------------------------------------
// Purpose: Delete a vertical column of samples between the selection
// markers.  If excise_time is true, shifts remaining samples left
// Input  : excise_time - 
//-----------------------------------------------------------------------------
void ExpressionTool::OnDeleteSelection( bool excise_time )
{
	if ( !m_bSelectionActive )
		return;

	// Force selection of everything again!
	SelectPoints( m_flSelection[ 0 ], m_flSelection[ 1 ] );

	int i, t;

	char const *undotext = excise_time ? "Excise column" : "Delete column";

	float shift_left_time = m_flSelection[ 1 ] - m_flSelection[ 0 ];
	Assert( shift_left_time > 0.0f );

	g_pChoreoView->SetDirty( true );
	g_pChoreoView->PushUndo( undotext );

	for ( int controller = 0; controller < GLOBAL_STUDIO_FLEX_CONTROL_COUNT; controller++ )
	{
		TimelineItem *item = m_pWorkspace->GetItem( controller );
		if ( !item )
			continue;

		CFlexAnimationTrack *track = item->GetSafeTrack();
		if ( !track )
			continue;

		for ( t = 0; t < 2; t++ )
		{
			for ( i = track->GetNumSamples( t ) - 1; i >= 0 ; i-- )
			{
				CExpressionSample *sample = track->GetSample( i, t );
				if ( !sample->selected )
					continue;

				track->RemoveSample( i, t );
			}

			if ( !excise_time )
				continue;

	
			// Now shift things after m_flSelection[0] to the left
			for ( i = track->GetNumSamples( t ) - 1; i >= 0 ; i-- )
			{
				CExpressionSample *sample = track->GetSample( i, t );
				if ( sample->time < m_flSelection[ 1 ] )
					continue;

				// Shift it
				sample->time -= shift_left_time;
			}
		}

		item->DrawSelf();
	}

	g_pChoreoView->PushRedo( undotext );

	// Clear selection and redraw()
	DeselectAll();
}

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
void ExpressionTool::OnResetItemSize()
{
	TimelineItem *item = m_pWorkspace->GetClickedItem();
	if ( !item )
		return;

	item->ResetHeight();
	m_pWorkspace->LayoutItems( true );
	redraw();
}

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
void ExpressionTool::OnResetAllItemSizes()
{
	for ( int controller = 0; controller < GLOBAL_STUDIO_FLEX_CONTROL_COUNT; controller++ )
	{
		TimelineItem *item = m_pWorkspace->GetItem( controller );
		if ( !item )
			continue;
		item->ResetHeight();
	}

	m_pWorkspace->LayoutItems( true );
	redraw();
}

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
void ExpressionTool::OnScaleSamples()
{
	int t, i;

	//Scale samples
	CInputParams params;
	memset( &params, 0, sizeof( params ) );

	strcpy( params.m_szDialogTitle, "Scale selected samples" );
	strcpy( params.m_szPrompt, "Factor:" );
	strcpy( params.m_szInputText, "1.0" );

	if ( !InputProperties( &params ) )
		return;

	float scale_factor = atof( params.m_szInputText );
	if( scale_factor <= 0.0f )
	{
		Con_Printf( "Can't scale to %.2f\n", scale_factor );
	}

	char const *undotext = "Scale samples";

	g_pChoreoView->SetDirty( true );
	g_pChoreoView->PushUndo( undotext );

	for ( int controller = 0; controller < GLOBAL_STUDIO_FLEX_CONTROL_COUNT; controller++ )
	{
		TimelineItem *item = m_pWorkspace->GetItem( controller );
		if ( !item )
			continue;

		CFlexAnimationTrack *track = item->GetSafeTrack();
		if ( !track )
			continue;

		for ( t = 0; t < 2; t++ )
		{
			for ( i = track->GetNumSamples( t ) - 1; i >= 0 ; i-- )
			{
				CExpressionSample *sample = track->GetSample( i, t );
				if ( !sample->selected )
					continue;

				// Scale it
				float curvalue = sample->value;
				curvalue *= scale_factor;
				// Clamp it
				curvalue = clamp( curvalue, 0.0f, 1.0f );
				sample->value = curvalue;
			}
		}
	}

	g_pChoreoView->PushRedo( undotext );

	m_pWorkspace->redraw();
	redraw();
}

void ExpressionTool::OnModelChanged()
{
	SetEvent( NULL );
	redraw();
}

void ExpressionTool::OnEdgeProperties()
{
	TimelineItem *item = m_pWorkspace->GetClickedItem();
	if ( !item )
		return;

	CFlexAnimationTrack *track = item->GetSafeTrack();
	if ( !track )
		return;

	CEdgePropertiesParams params;
	Q_memset( &params, 0, sizeof( params ) );
	Q_strcpy( params.m_szDialogTitle, "Edge Properties" );

	params.SetFromFlexTrack( track );

	if ( !EdgeProperties( &params ) )
	{
		return;
	}

	char const *undotext = "Change Edge Properties";
	
	g_pChoreoView->SetDirty( true );
	g_pChoreoView->PushUndo( undotext );

	// Apply changes.
	params.ApplyToTrack( track );

	g_pChoreoView->PushRedo( undotext );

	m_pWorkspace->redraw();
	redraw();
}

float ExpressionTool::GetScrubberSceneTime()
{
	CChoreoEvent *ev = GetSafeEvent();
	if ( !ev )
		return 0.0f;

	float curtime = GetScrub();
	curtime += ev->GetStartTime();
	return curtime;
}

void ExpressionTool::GetTimelineItems( CUtlVector< TimelineItem * >& list )
{
	for ( int i = 0; i < GLOBAL_STUDIO_FLEX_CONTROL_COUNT; i++ )
	{
		TimelineItem *item = m_pWorkspace->GetItem( i );
		if ( !item )
			continue;

		list.AddToTail( item );
	}
}



bool ExpressionTool::HasCopiedColumn()
{
	return m_ColumnCopy.m_bActive;
}

void ExpressionTool::OnCopyColumn()
{
	m_ColumnCopy.Reset();

	m_ColumnCopy.m_bActive = true;
	m_ColumnCopy.m_flCopyTimes[ 0 ] = m_flSelection[ 0 ];
	m_ColumnCopy.m_flCopyTimes[ 1 ] = m_flSelection[ 1 ];

	for ( int controller = 0; controller < GLOBAL_STUDIO_FLEX_CONTROL_COUNT; ++controller )
	{
		TimelineItem *item = m_pWorkspace->GetItem( controller );
		if ( !item )
			continue;

		CFlexAnimationTrack *track = item->GetSafeTrack();
		if ( !track )
			continue;

		for ( int t = 0; t < 2; t++ )
		{
			for ( int i = track->GetNumSamples( t ) - 1; i >= 0 ; i-- )
			{
				CExpressionSample *sample = track->GetSample( i, t );
				if ( !sample->selected )
					continue;

				// Add to dictionary
				CExpressionSample copy( *sample );
				copy.selected = false;

				int tIndex = m_ColumnCopy.m_Data.Find( track->GetFlexControllerName() );
				if ( tIndex == m_ColumnCopy.m_Data.InvalidIndex() )
				{
					tIndex = m_ColumnCopy.m_Data.Insert( track->GetFlexControllerName() );
				}

				CColumnCopier::CTrackData &data = m_ColumnCopy.m_Data[ tIndex ];
				data.m_Samples[ t ].AddToTail( copy );
			}
		}
	}
}

void ExpressionTool::OnPasteColumn()
{
	if ( !m_ColumnCopy.m_bActive )
	{
		Msg( "Nothing to paste\n" );
		return;
	}

	float flPasteTime = GetTimeForClickedPos();

	float flPasteEndTime = flPasteTime + m_ColumnCopy.m_flCopyTimes[ 1 ] - m_ColumnCopy.m_flCopyTimes[ 0 ];

	// Clear selection and redraw()
	DeselectAll();

	// Select everthing in the paste region so we can delete the existing stuff
	SelectPoints( flPasteTime, flPasteEndTime );

	int i, t;

	char const *undotext = "Paste column";

	g_pChoreoView->SetDirty( true );
	g_pChoreoView->PushUndo( undotext );

	for ( int controller = 0; controller < GLOBAL_STUDIO_FLEX_CONTROL_COUNT; controller++ )
	{
		TimelineItem *item = m_pWorkspace->GetItem( controller );
		if ( !item )
			continue;

		CFlexAnimationTrack *track = item->GetSafeTrack();
		if ( !track )
			continue;

		int tIndex = m_ColumnCopy.m_Data.Find( track->GetFlexControllerName() );

		for ( t = 0; t < 2; t++ )
		{
			// Remove all selected samples
			for ( i = track->GetNumSamples( t ) - 1; i >= 0 ; i-- )
			{
				CExpressionSample *sample = track->GetSample( i, t );
				if ( !sample->selected )
					continue;

				track->RemoveSample( i, t );
			}

			// Now add the new samples, if any in the time selection
			if ( tIndex != m_ColumnCopy.m_Data.InvalidIndex() )
			{
				CColumnCopier::CTrackData &data = m_ColumnCopy.m_Data[ tIndex ];

				for ( int j = 0; j < data.m_Samples[ t ].Count(); ++j )
				{
					CExpressionSample *s = &data.m_Samples[ t ][ j ];
					CExpressionSample *newSample = track->AddSample( s->time - m_ColumnCopy.m_flCopyTimes[ 0 ] + flPasteTime, s->value, t );
					newSample->selected = true;
				}
			}
			track->Resort( t );
		}

		item->DrawSelf();
	}

	g_pChoreoView->PushRedo( undotext );
}

void ExpressionTool::ClearColumnCopy()
{
	m_ColumnCopy.Reset();
}