tf2/tf2_src/utils/hlfaceposer/timelineitem.cpp

//========= Copyright Valve Corporation, All rights reserved. ============//
//
// Purpose: 
//
// $NoKeywords: $
//=============================================================================//
#include "hlfaceposer.h"
#include <stdio.h>
#include "TimelineItem.h"
#include "choreowidgetdrawhelper.h"
#include "mathlib/mathlib.h"
#include "expressions.h"
#include "StudioModel.h"
#include "expclass.h"
#include "mathlib/mathlib.h"
#include "ExpressionTool.h"
#include "choreoevent.h"
#include "choreoscene.h"
#include "choreoactor.h"
#include "choreochannel.h"
#include "ChoreoView.h"
#include "ControlPanel.h"
#include "faceposer_models.h"
#include "MatSysWin.h"
#include "choreoviewcolors.h"
#include "ifaceposersound.h"
#include "curveeditorhelpers.h"

extern double realtime;

#define DOUBLE_CLICK_TIME 0.2

#define GROW_HANDLE_WIDTH	66
#define GROW_HANDLE_HEIGHT	8
#define GROW_HANDLE_INSETPIXELS 8

#define TIMELINEITEM_DEFAULT_HEIGHT 100

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
TimelineItem::TimelineItem( mxWindow *workspace )
{
	m_pHelper = new CCurveEditorHelper< TimelineItem >( this );

	m_pWorkspace = workspace;

	m_nDragging = DRAGTYPE_NONE;
	m_nLastX = 0;
	m_nLastY = 0;
	m_nStartX = 0;
	m_nStartY = 0;

	SetExpressionInfo( NULL, 0 );

	m_nNumSelected = 0;

	m_nEditType = 0;

	SetCollapsed( false );
	SetActive( false );

	m_nUndoSetup = 0;
	m_rcBounds.top = 0;
	m_rcBounds.bottom = 0;
	m_rcBounds.left = 0;
	m_rcBounds.right = 0;
	m_bVisible = false;
	m_flLastClickTime = -1;

	m_nCurrentHeight = TIMELINEITEM_DEFAULT_HEIGHT;
}

TimelineItem::~TimelineItem( void )
{
	delete m_pHelper;
}

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
void TimelineItem::ResetHeight()
{
	m_nCurrentHeight = TIMELINEITEM_DEFAULT_HEIGHT;
}

//-----------------------------------------------------------------------------
// Purpose: 
// Input  : mx - 
// Output : float
//-----------------------------------------------------------------------------
float TimelineItem::GetTimeForMouse( int mx, bool clip /*= false*/ )
{
	float start, end;
	g_pExpressionTool->GetStartAndEndTime( start, end );

	if ( clip )
	{
		if ( mx < m_rcBounds.left )
		{
			return start;
		}
		else if ( mx >= m_rcBounds.right )
		{
			return end;
		}
	}

	float frac = (float)( mx - m_rcBounds.left ) / (float)( m_rcBounds.right - m_rcBounds.left );
	float t = start + frac * ( end - start );
	return t;
}

//-----------------------------------------------------------------------------
// Purpose: 
// Input  : t - 
// Output : int
//-----------------------------------------------------------------------------
int TimelineItem::GetMouseForTime( float t, bool *clipped /*= NULL*/ )
{
	float start, end;
	g_pExpressionTool->GetStartAndEndTime( start, end );

	float frac = ( t - start ) / ( end - start );

	if ( frac < 0.0 || frac > 1.0 )
	{
		if ( clipped )
		{
			*clipped = true;
		}
	}

	int mx = m_rcBounds.left + ( int ) ( frac * (float)( m_rcBounds.right - m_rcBounds.left ) );

	return mx;
}

int TimelineItem::NumSamples()
{
	CFlexAnimationTrack *track = GetSafeTrack();
	if ( !track )
		return 0;

	// Aggregate both types of tracks together
	return track->GetNumSamples( 0 ) + track->GetNumSamples( 1 );
	// return track->GetNumSamples( m_nEditType );
}

CExpressionSample *TimelineItem::GetSample( int idx )
{
	CFlexAnimationTrack *track = GetSafeTrack();
	if ( !track )
		return NULL;

	if ( idx >= track->GetNumSamples( 0 ) )
	{
		// Rebase and look at left/right track instead
		idx -= track->GetNumSamples( 0 );
		return track->GetSample( idx, 1 );
	}
	return track->GetSample( idx, 0 );
}

CExpressionSample *TimelineItem::GetSampleUnderMouse( int mx, int my, float tolerance /*= FP_TL_SELECTION_TOLERANCE*/ )
{
	CFlexAnimationTrack *track = GetSafeTrack();
	if ( !track )
		return NULL;

	CChoreoEvent *e = track->GetEvent();
	if ( !e )
		return NULL;

	float closest_dist = 9999999.f;
	CExpressionSample *bestsample = NULL;

	// Add a sample point
	int height = m_rcBounds.bottom - m_rcBounds.top;

	mx += m_rcBounds.left;

	for ( int i = 0; i < track->GetNumSamples( m_nEditType ); i++ )
	{
		CExpressionSample *sample = track->GetSample( i, m_nEditType );

		bool clipped = false;
		int px = GetMouseForTime( sample->time, &clipped );		
		int py = height * ( 1.0f - sample->value ); 

		int dx = px - mx;
		int dy = py - my;

		float dist = sqrt( (float)(dx * dx + dy * dy) );
		if ( dist < closest_dist )
		{
			bestsample = sample;
			closest_dist = dist;
		}
	}

	// Not close to any of them!!!
	if ( ( tolerance != 0.0f ) && 
		( closest_dist > tolerance ) )
		return NULL;

	return bestsample;
}

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
void TimelineItem::DeselectAll( void )
{
	g_pExpressionTool->DeselectAll();
}

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
void TimelineItem::SelectAll( void )
{
	CFlexAnimationTrack *track = GetSafeTrack();
	if ( !track )
		return;

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

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
void TimelineItem::Delete( void )
{
	g_pExpressionTool->DeleteSelectedSamples();
}

//-----------------------------------------------------------------------------
// Purpose: 
// Input  : sample - 
//-----------------------------------------------------------------------------
void TimelineItem::AddSample( CExpressionSample const& sample )
{
	CFlexAnimationTrack *track = GetSafeTrack();
	if ( !track )
		return;

	PreDataChanged( "Add sample point" );

	track->AddSample( sample.time, sample.value, m_nEditType );
	track->Resort( m_nEditType );

	SetActive( true );

	PostDataChanged( "Add sample point" );
}

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
int TimelineItem::CountSelected( void )
{
	m_nNumSelected = m_pHelper->CountSelected( false );
	return m_nNumSelected;
}

void TimelineItem::SetMousePositionForEvent( mxEvent *event )
{
	POINT pt;
	GetCursorPos( &pt );
	ScreenToClient( (HWND)m_pWorkspace->getHandle(), &pt );

	pt.x -= m_rcBounds.left;
	pt.y -= m_rcBounds.top;

	event->x = pt.x;
	event->y = pt.y;
}

int	TimelineItem::handleEvent( mxEvent *event )
{
	int iret = 0;

	// Give helper a shot at the event
	if ( m_pHelper->HelperHandleEvent( event ) )
	{
		return 1;
	}

	switch ( event->event )
	{
	case mxEvent::KeyDown:
		{
			switch ( event->key )
			{
			default:
				iret = g_pChoreoView->HandleZoomKey( g_pExpressionTool, event->key );
				break;
			case VK_ESCAPE:
				DeselectAll();
				DrawSelf();
				break;
			case VK_DELETE:
				Delete();
				DrawSelf();
				break;
			case 'C':
				Copy();
				DrawSelf();
				break;
			case 'V':
				Paste();
				DrawSelf();
				break;
			case 'J':
				{
					g_pExpressionTool->OnCopyToFlex( g_pExpressionTool->GetScrubberSceneTime(), true );
				}
				break;
			case 'K':
				{
					g_pExpressionTool->OnCopyFromFlex( g_pExpressionTool->GetScrubberSceneTime(), false );
				}
				break;
			case 188: // VK_OEM_COMMA:
				{
					g_pExpressionTool->SetScrubTargetTime( 0.0f );
				}
				break;
			case 190: // VK_OEM_PERIOD:
				{
					CChoreoScene *scene = g_pChoreoView->GetScene();
					if ( scene )
					{
						g_pExpressionTool->SetScrubTargetTime( scene->FindStopTime() );
					}
				}
				break;
			case VK_LEFT: 
				{
					CChoreoScene *scene = g_pChoreoView->GetScene();
					if ( scene && scene->GetSceneFPS() > 0 )
					{
						float curscrub = g_pExpressionTool->GetScrub();
						curscrub -= ( 1.0f / (float)scene->GetSceneFPS() );
						curscrub = max( curscrub, 0.0f );
						g_pExpressionTool->SetScrubTargetTime( curscrub );
					}
				}
				break;
			case VK_RIGHT: 
				{
					CChoreoScene *scene = g_pChoreoView->GetScene();
					if ( scene && scene->GetSceneFPS() > 0 )
					{
						float curscrub = g_pExpressionTool->GetScrub();
						curscrub += ( 1.0f / (float)scene->GetSceneFPS() );
						curscrub = min( curscrub, scene->FindStopTime() );
						g_pExpressionTool->SetScrubTargetTime( curscrub );
					}
				}
				break;
			case 191:
				{
					if ( g_pChoreoView->IsPlayingScene() )
					{
						g_pChoreoView->StopScene();
					}
				}
				break;
			}
			iret = 1;
		}
		break;
	case mxEvent::KeyUp:
		{
			switch ( event->key )
			{
			case VK_SPACE:
				{
					CFlexAnimationTrack *track = GetSafeTrack();
					if ( track && track->IsComboType() )
					{
						SetEditType( m_nEditType == 0 ? 1 : 0 );
						DrawSelf();
					}
				}
				break;
			}
			iret = 1;
		}
		break;
	case mxEvent::MouseDown:
		{
			sound->Flush();

			SetFocus( (HWND)g_pExpressionTool->getHandle() );

			int height = m_rcBounds.bottom - m_rcBounds.top;

			bool rightbutton = ( event->buttons & mxEvent::MouseRightButton ) ? true : false;

			if ( m_nDragging == DRAGTYPE_NONE )
			{
				bool ctrlDown = ( event->modifiers & mxEvent::KeyCtrl ) ? true : false;

				CExpressionSample *sample = GetSampleUnderMouse( event->x, event->y, ctrlDown ? FP_TL_ADDSAMPLE_TOLERANCE : FP_TL_SELECTION_TOLERANCE );

				if ( IsMouseOverGrowHandle( (short)event->x, (short)event->y ) )
				{
					m_nDragging = DRAGTYPE_GROW;
					m_nLastX = (short)event->x;
					m_nLastY = (short)event->y;

					m_nStartX = m_nLastX;
					m_nStartY = m_nLastY;

					MouseDrag( (short)event->x, (short)event->y, event->modifiers );

					DrawGrowRect();
				}
				else if ( sample )
				{
					if  ( event->modifiers & mxEvent::KeyShift ) 
					{
						sample->selected = !sample->selected;
						DrawSelf();
					}
					else if ( sample->selected )
					{
						m_nDragging = rightbutton ? DRAGTYPE_MOVEPOINTS_TIME : DRAGTYPE_MOVEPOINTS_VALUE;
						m_nLastX = (short)event->x;
						m_nLastY = (short)event->y;

						m_nStartX = m_nLastX;
						m_nStartY = m_nLastY;

						PreDataChanged( "Move sample point(s)" );

						MouseDrag( (short)event->x, (short)event->y, event->modifiers );

						DrawSelf();
					}
					else
					{
						if  ( !( event->modifiers & mxEvent::KeyShift ) ) 
						{
							DeselectAll();
							DrawSelf();
						}

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

						m_nStartX = m_nLastX;
						m_nStartY = m_nLastY;

						MouseDrag( (short)event->x, (short)event->y, event->modifiers );

						DrawFocusRect();
					}
				}
				else if ( event->modifiers & mxEvent::KeyCtrl )
				{
					CChoreoEvent *e = g_pExpressionTool->GetSafeEvent();
					if ( e )
					{
						// Add a sample point
						float t = GetTimeForMouse( (short)event->x + m_rcBounds.left );

						CExpressionSample sample;
						sample.time = FacePoser_SnapTime( t );
						sample.value = 1.0f - (float)( (short)( event->y ) ) / (float)height;
						sample.selected = false;

						AddSample( sample );

						DrawSelf();
					}
				}
				else
				{
					if ( rightbutton )
					{
						POINT pt;
						pt.x = event->x;
						pt.y = event->y;
						ClientToScreen( (HWND)m_pWorkspace->getHandle(), &pt );
						ScreenToClient( (HWND)g_pExpressionTool->getHandle(), &pt );
						event->x = pt.x;
						event->y = pt.y;
						g_pExpressionTool->ShowContextMenu( event, true );
						return iret;
					}

					if  ( !( event->modifiers & mxEvent::KeyShift ) ) 
					{
						DeselectAll();
						DrawSelf();
					}

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

					m_nStartX = m_nLastX;
					m_nStartY = m_nLastY;

					MouseDrag( (short)event->x, (short)event->y, event->modifiers );

					DrawFocusRect();
				}
			}
			iret = 1;
		}
		break;
	case mxEvent::MouseDrag:
	case mxEvent::MouseMove:
		{
			if ( m_nDragging != DRAGTYPE_NONE )
			{
				if ( m_nDragging == DRAGTYPE_SELECTION )
				{
					DrawFocusRect();
				}
				else if ( m_nDragging == DRAGTYPE_GROW )
				{
					DrawGrowRect();
				}

				MouseDrag( (short)event->x, (short)event->y, event->modifiers );
				
				if ( m_nDragging == DRAGTYPE_SELECTION )
				{
					DrawFocusRect();
				}
				else if ( m_nDragging == DRAGTYPE_GROW )
				{
					DrawGrowRect();
				}

				if ( m_nDragging == DRAGTYPE_MOVEPOINTS_TIME ||
					 m_nDragging == DRAGTYPE_MOVEPOINTS_VALUE )
				{
					DrawSelf();
				}
			}
			else
			{
				// See if anything is selected
				CountSelected();
				if ( m_nNumSelected <= 0 && g_pExpressionTool->IsFocusItem( this ) )
				{
					// Nothing selected
					// Draw auto highlight
					DrawAutoHighlight( event );
				}
			}
			iret = 1;
		}
		break;
	case mxEvent::MouseUp:
		{
			bool overgrow = IsMouseOverGrowHandle( (short)event->x, (short)event->y );
				
			if ( m_nDragging != DRAGTYPE_NONE )
			{
				if ( m_nDragging == DRAGTYPE_SELECTION )
				{
					DrawFocusRect();
				}
				else if ( m_nDragging == DRAGTYPE_GROW )
				{
					DrawGrowRect();
				}

				MouseDrag( (short)event->x, (short)event->y, event->modifiers, true );

				if ( m_nDragging == DRAGTYPE_GROW )
				{
					// Finish grow by resizing control
					int desiredheight = m_nCurrentHeight + event->y - m_nStartY;
					if ( desiredheight >= 10 )
					{
						m_nCurrentHeight = desiredheight;
						g_pExpressionTool->LayoutItems( true );
					}
				}
				else if ( m_nDragging != DRAGTYPE_MOVEPOINTS_VALUE &&
					 m_nDragging != DRAGTYPE_MOVEPOINTS_TIME )
				{
					SelectPoints();
				}
				else
				{
					PostDataChanged( "Move sample point(s)" );
				}

				m_nDragging = DRAGTYPE_NONE;

				DrawSelf();
			}
			
			bool rightbutton = ( event->buttons & mxEvent::MouseRightButton ) ? true : false;
			bool shift = ( event->modifiers & mxEvent::KeyShift ) ? true : false;
			bool ctrl = ( event->modifiers & mxEvent::KeyCtrl ) ? true : false;

			if ( !rightbutton && !shift && !ctrl )
			{
				if ( realtime - m_flLastClickTime < DOUBLE_CLICK_TIME )
				{
					if ( overgrow || IsCollapsed() )
					{
						OnDoubleClicked();
					}
				}

				m_flLastClickTime = realtime;
			}

			iret = 1;
		}
		break;
	}

	return iret;
}

void TimelineItem::MouseDrag( int x, int y, int modifiers, bool snap /*=false*/ )
{
	if ( m_nDragging == DRAGTYPE_NONE )
		return;

	int width = m_rcBounds.right - m_rcBounds.left;
	int height = m_rcBounds.bottom - m_rcBounds.top;

	if ( m_nDragging == DRAGTYPE_MOVEPOINTS_TIME ||
		 m_nDragging == DRAGTYPE_MOVEPOINTS_VALUE )
	{
		int dx = x - m_nLastX;
		int dy = y - m_nLastY;

		if ( !( modifiers & mxEvent::KeyCtrl ) )
		{
			// Zero out motion on other axis
			if ( m_nDragging == DRAGTYPE_MOVEPOINTS_VALUE )
			{
				dx = 0;
				x = m_nLastX;
			}
			else
			{
				dy = 0;
				y = m_nLastY;
			}
		}

		float dfdx = (float)dx / g_pExpressionTool->GetPixelsPerSecond();
		float dfdy = (float)dy / (float)height;

		g_pExpressionTool->MoveSelectedSamples( dfdx, dfdy, snap );

		// Update the scrubber
		if ( (float)width > 0 )
		{
			float t = GetTimeForMouse( x +  m_rcBounds.left );
			g_pExpressionTool->ForceScrubPosition( t );

			g_pMatSysWindow->Frame();
		}
	}

	m_nLastX = x;
	m_nLastY = y;
}

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
void TimelineItem::DrawFocusRect( void )
{
	RECT rcFocus;
	
	rcFocus.left = m_nStartX < m_nLastX ? m_nStartX : m_nLastX;
	rcFocus.right = m_nStartX < m_nLastX ? m_nLastX : m_nStartX;

	rcFocus.top = m_nStartY < m_nLastY ? m_nStartY : m_nLastY;
	rcFocus.bottom = m_nStartY < m_nLastY ? m_nLastY : m_nStartY;

	POINT offset;
	offset.x = m_rcBounds.left;
	offset.y = m_rcBounds.top;
	ClientToScreen( (HWND)m_pWorkspace->getHandle(), &offset );
	OffsetRect( &rcFocus, offset.x, offset.y );

	HDC dc = GetDC( NULL );

	::DrawFocusRect( dc, &rcFocus );

	ReleaseDC( NULL, dc );
}

void TimelineItem::DrawSelf( void )
{
	CChoreoWidgetDrawHelper drawHelper( m_pWorkspace, m_rcBounds );
	Draw( drawHelper );
}

void TimelineItem::Draw( CChoreoWidgetDrawHelper& drawHelper )
{
	CFlexAnimationTrack *track = GetSafeTrack();
	if ( !track )
		return;

	CChoreoEvent *e = track->GetEvent();
	if ( !e )
		return;

	Assert( e->HasEndTime() );

	bool active = track && ( IsValid() || IsActive() );

	float starttime;
	float endtime;

	g_pExpressionTool->GetStartAndEndTime( starttime, endtime );

	CountSelected();
	int scount = GetNumSelected();

	COLORREF bgColor = RGB( 230, 230, 200 );
	if ( IsCollapsed() && active )
	{
		bgColor = RGB( 200, 230, 200 );
	}

	RECT rcClient = m_rcBounds;

	drawHelper.DrawFilledRect( bgColor, rcClient );

	COLORREF gray = RGB( 200, 200, 200 );

	DrawEventEnd( drawHelper );

	DrawRelativeTags( drawHelper );
	if ( !IsCollapsed() && track )
	{
		if ( m_nEditType == 1 )
		{
			float zero = track->GetZeroValue( m_nEditType, true );

			drawHelper.DrawColoredLine( RGB( 180, 200, 220 ), PS_SOLID, 1, 
				rcClient.left, ( rcClient.top * zero + rcClient.bottom * (1 - zero)) ,
				rcClient.right, ( rcClient.top * zero + rcClient.bottom  * (1 - zero)) );
		}

		drawHelper.DrawOutlinedRect( RGB( 100, 150, 200 ), PS_SOLID, 1, rcClient );

		// Draw grow handle into background...
		if ( CanHaveGrowHandle() )
		{
			RECT handleRect;
			GetGrowHandleRect( handleRect );
			DrawGrowHandle( drawHelper, handleRect );
		}

		// Draw left/right underneath amount so go backbard
		for ( int type = ( track->IsComboType() ? 1 : 0 ); type >= 0; type-- )
		{
			COLORREF lineColor = ( type == m_nEditType ) ? RGB( 0, 0, 255 ) : gray;
			COLORREF shadowColor = ( type == m_nEditType ) ? RGB( 150, 150, 250 ) : gray;
			COLORREF dotColor = ( type == m_nEditType ) ? RGB( 0, 0, 255 ) : gray;
			COLORREF dotColorSelected = ( type == m_nEditType ) ? RGB( 240, 80, 20 ) : gray;

			int height = rcClient.bottom - rcClient.top;
			int bottom = rcClient.bottom;

			// Fixme, could look at 1st derivative and do more sampling at high rate of change?
			// or near actual sample points!
			float linelength = g_pExpressionTool->IsFocusItem( this ) ? 2.0f : 8.0f;

			float timestepperpixel = linelength / g_pExpressionTool->GetPixelsPerSecond();

			float stoptime = min( endtime, e->GetDuration() );
			
			float prev_t = starttime;
			float prev_value = track->GetFracIntensity( prev_t, type );

			CUtlVector< POINT > segments;

			/*
			if (type == m_nEditType)
			{
				// draw hermite version of time step
				float i0, i1, i2;
				float time10hz = starttime;

				i0 = track->GetFracIntensity( time10hz, type );
				i1 = i0;
				time10hz = starttime + 0.1;
				i2 = track->GetFracIntensity( time10hz, type );;
				
				for ( float t = starttime; t <= stoptime; t += timestepperpixel )
				{
					while (t >= time10hz)
					{
						time10hz += 0.1;
						i0 = i1;
						i1 = i2;
						i2 = track->GetFracIntensity( time10hz, type );;
					}

					float value = Hermite_Spline( i0, i1, i2, (t - time10hz + 0.1) / 0.1 );

					int prevx, x;

					bool clipped1, clipped2;
					x = GetMouseForTime( t, &clipped1 );
					prevx = GetMouseForTime( prev_t, &clipped2 );

					//if ( !clipped1 && !clipped2 )
					{
						// Draw segment
						//drawHelper.DrawColoredLine( lineColor, PS_SOLID, 1,
						//	prevx, bottom - prev_value * height,
						//	x, bottom - value * height );
						
						POINT pt;

						if ( segments.Count() == 0 )
						{
							pt.x = prevx;	
							pt.y = bottom - prev_value * height;

							segments.AddToTail( pt );
						}

						pt.x = x;
						pt.y = bottom - value * height;

						segments.AddToTail( pt );
					}

					prev_t = t;
					prev_value = value;
				}

				if ( segments.Count() >= 2  )
				{
					drawHelper.DrawColoredPolyLine( shadowColor, PS_SOLID, 1, segments );
				}

				segments.RemoveAll();
			}
			*/
			for ( float t = starttime; t <= stoptime; t += timestepperpixel )
			{
				float value = track->GetFracIntensity( t, type );

				int prevx, x;

				bool clipped1, clipped2;
				x = GetMouseForTime( t, &clipped1 );
				prevx = GetMouseForTime( prev_t, &clipped2 );

				//if ( !clipped1 && !clipped2 )
				{
					// Draw segment
					//drawHelper.DrawColoredLine( lineColor, PS_SOLID, 1,
					//	prevx, bottom - prev_value * height,
					//	x, bottom - value * height );
					
					POINT pt;

					if ( segments.Count() == 0 )
					{
						pt.x = prevx;	
						pt.y = bottom - prev_value * height;

						segments.AddToTail( pt );
					}

					pt.x = x;
					pt.y = bottom - value * height;

					segments.AddToTail( pt );
				}

				prev_t = t;
				prev_value = value;
			}

			if ( segments.Count() >= 2  )
			{
				drawHelper.DrawColoredPolyLine( lineColor, PS_SOLID, 1, segments );
			}

			for ( int sample = 0; sample < track->GetNumSamples( type ); sample++ )
			{
				bool dummy;
				CExpressionSample *start = track->GetBoundedSample( sample, dummy, type );

				/*
				int pixel = (int)( ( start->time / event_time ) * width + 0.5f);
				int x = m_rcBounds.left + pixel;
				float roundedfrac = (float)pixel / (float)width;
				*/
				float value = start->value; // track->GetFracIntensity( start->time, type );
				bool clipped = false;
				int x = GetMouseForTime( start->time, &clipped );
				if ( clipped )
					continue;
				int y = bottom - value * height;

				int dotsize = 6;
				int dotSizeSelected = 6;

				COLORREF clr = dotColor;
				COLORREF clrSelected = dotColorSelected;

				drawHelper.DrawCircle( 
					start->selected ? clrSelected : clr, 
					x, y, 
					start->selected ? dotSizeSelected : dotsize,
					true );


				if ( !start->selected )
					continue;

				if ( start->GetCurveType() == CURVE_DEFAULT )
					continue;

				// Draw curve type indicator...
				char sz[ 128 ];
				Q_snprintf( sz, sizeof( sz ), "%s", Interpolator_NameForCurveType( start->GetCurveType(), true ) );
				RECT rc;
				int fontSize = 9;
				rc.top = clamp( y + 5, rcClient.top + 2, rcClient.bottom - 2 - fontSize );
				rc.bottom = rc.top + fontSize + 1;
				rc.left = x - 75;
				rc.right = x + 175;
				drawHelper.DrawColoredText( "Arial", fontSize, 500, shadowColor, rc, sz );
			}
		}
	}

	if ( track && track->IsComboType() && !IsCollapsed() )
	{
		RECT title = rcClient;
		title.left += 10;
		title.top += 14;
		title.bottom = title.top + 9;

		char sz[ 128 ];

		if ( m_nEditType == 1 )
		{
			sprintf( sz, "left" );

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

			sprintf( sz, "right" );

			title.top = rcClient.bottom - 22;
			title.bottom = rcClient.bottom;

			drawHelper.DrawColoredText( "Arial", 9, 500, RGB( 0, 0, 255 ), title, sz );
		}

		int mid = ( rcClient.top + rcClient.bottom ) / 2;

		title.top = mid - 10;
		title.bottom = mid;

		sprintf( sz, "editmode:  <%s>", m_nEditType == 0 ? "amount" : "left/right" );

		drawHelper.DrawColoredText( "Arial", 9, 500, RGB( 0, 0, 255 ), title, sz );
	}

	if ( track )
	{
		RECT title = rcClient;
		title.left += 2;
		title.top += 2;
		title.bottom = title.top + 9;

		char const *name = track->GetFlexControllerName();
		char sz[ 128 ];

		if ( scount > 0 )
		{
			sprintf( sz, "{%i} - ", scount );

			int len = drawHelper.CalcTextWidth( "Arial", 9, 500, sz );
			drawHelper.DrawColoredText( "Arial", 9, 500, 
				RGB( 120, 120, 0 ), title, sz );

			title.left += len + 2;
		}

		sprintf( sz, "%s -", name );

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

		drawHelper.DrawColoredText( "Arial", 9, 500, 
			active ? RGB( 0, 150, 100 ) : RGB( 100, 100, 100 ), 
			title, sz );

		sprintf( sz, "%s", IsActive() ? "enabled" : "disabled" );

		title.left += len + 2;

		len = drawHelper.CalcTextWidth( "Arial", 9, 500, sz );
		drawHelper.DrawColoredText( "Arial", 9, 500, 
			active ? RGB( 0, 150, 100 ) : RGB( 100, 100, 100 ), 
			title, sz );

		if ( active )
		{
			title.left += len + 2;

			sprintf( sz, " <%i>", track->GetNumSamples( 0 ) );

			len = drawHelper.CalcTextWidth( "Arial", 9, 500, sz );
			drawHelper.DrawColoredText( "Arial", 9, 500, RGB( 220, 0, 00 ), title, sz );
		}
	}
}

void TimelineItem::DrawAutoHighlight( mxEvent *event )
{
	if ( IsCollapsed() )
		return;
	
	CFlexAnimationTrack *track = GetSafeTrack();
	if ( !track )
		return;

	CExpressionSample *hover = GetSampleUnderMouse( event->x, event->y, 0.0f );
	CChoreoWidgetDrawHelper drawHelper( m_pWorkspace, m_rcBounds, true );

	RECT rcClient = m_rcBounds;

	// Draw left/right underneath amount so go backbard
	int type = m_nEditType;

	COLORREF dotColor = RGB( 0, 0, 255 );
	COLORREF dotColorSelected = RGB( 240, 80, 20 );
	COLORREF clrHighlighted = RGB( 0, 200, 0 );

	int height = rcClient.bottom - rcClient.top;
	int bottom = rcClient.bottom;

	int dotsize = 6;
	int dotSizeSelected = 6;
	int dotSizeHighlighted = 6;

	COLORREF clr = dotColor;
	COLORREF clrSelected = dotColorSelected;
	COLORREF bgColor = RGB( 230, 230, 200 );

	// Fixme, could look at 1st derivative and do more sampling at high rate of change?
	// or near actual sample points!
	for ( int sample = 0; sample < track->GetNumSamples( type ); sample++ )
	{
		bool dummy;
		CExpressionSample *start = track->GetBoundedSample( sample, dummy, type );

		float value = start->value;
		bool clipped = false;
		int x = GetMouseForTime( start->time, &clipped );
		if ( clipped )
			continue;
		int y = bottom - value * height;

		if ( hover == start )
		{
			drawHelper.DrawCircle( 
				bgColor, 
				x, y, 
				dotSizeHighlighted,
				true );

			drawHelper.DrawCircle( 
				clrHighlighted, 
				x, y, 
				dotSizeHighlighted,
				false );


		}
		else
		{
			drawHelper.DrawCircle( 
				start->selected ? clrSelected : clr, 
				x, y, 
				start->selected ? dotSizeSelected : dotsize,
				true );
		}
	}
}

//-----------------------------------------------------------------------------
// Purpose: 
// Input  : drawHelper - 
//-----------------------------------------------------------------------------
void TimelineItem::DrawRelativeTags( CChoreoWidgetDrawHelper& drawHelper )
{
	CFlexAnimationTrack *track = GetSafeTrack();
	if ( !track )
		return;

	CChoreoEvent *event = track->GetEvent();
	if ( !event )
		return;

	float duration = event->GetDuration();

	if ( duration <= 0.0f )
		return;

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

	RECT rcClient = m_rcBounds;;
	//drawHelper.GetClientRect( rcClient );

	// 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 = false;
					int tagx = GetMouseForTime( tag->GetStartTime() - event->GetStartTime(), &clipped );
					if ( clipped )
						continue;

					drawHelper.DrawColoredLine( RGB( 180, 180, 220 ), PS_SOLID, 1, tagx, rcClient.top, tagx, rcClient.bottom );
				}
			}
		}
	}

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

		bool clipped = false;
		int tagx = GetMouseForTime( tag->GetStartTime() - event->GetStartTime(), &clipped );
		if ( clipped )
			continue;
		
		// Draw relative tag marker
		drawHelper.DrawColoredLine( RGB( 220, 180, 180 ), PS_SOLID, 1, tagx, rcClient.top, tagx, rcClient.bottom );
	}
}

//-----------------------------------------------------------------------------
// Purpose: 
// Input  : *exp - 
//			flexnum - 
//-----------------------------------------------------------------------------
void TimelineItem::SetExpressionInfo( CFlexAnimationTrack *track, int flexnum )
{
	m_szTrackName[ 0 ] = 0;
	if ( track )
	{
		V_strcpy_safe( m_szTrackName, track->GetFlexControllerName() );
		SetActive( track->IsTrackActive() );
	}

	m_nFlexNum = flexnum;
}

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
void TimelineItem::Copy( void )
{
	if ( !g_pExpressionTool )
		return;

	CFlexAnimationTrack *track = GetSafeTrack();
	if ( !track )
		return;

	g_pExpressionTool->Copy( track );
}

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
void TimelineItem::Paste( void )
{
	if ( !g_pExpressionTool )
		return;

	if ( !g_pExpressionTool->HasCopyData() )
		return;

	CFlexAnimationTrack *track = GetSafeTrack();
	if ( !track )
		return;

	g_pExpressionTool->Paste( track );
}

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
void TimelineItem::Clear( bool preserveundo )
{
	CFlexAnimationTrack *track = GetSafeTrack();
	if ( !track )
		return;

	if ( preserveundo )
	{
		PreDataChanged( "Clear" );
	}

	track->Clear();

	if ( preserveundo )
	{
		PostDataChanged( "Clear" );
	}
}

//-----------------------------------------------------------------------------
// Purpose: 
// Input  : state - 
//-----------------------------------------------------------------------------
void TimelineItem::SetCollapsed( bool state )
{
	m_bCollapsed = state;
}

//-----------------------------------------------------------------------------
// Purpose: 
// Output : Returns true on success, false on failure.
//-----------------------------------------------------------------------------
bool TimelineItem::IsCollapsed( void ) const
{
	return m_bCollapsed;
}

//-----------------------------------------------------------------------------
// Purpose: 
// Output : int
//-----------------------------------------------------------------------------
int TimelineItem::GetHeight( void )
{
	return ( IsCollapsed() ? 12 : m_nCurrentHeight );
}

//-----------------------------------------------------------------------------
// Purpose: 
// Input  : state - 
//-----------------------------------------------------------------------------
void TimelineItem::SetActive( bool state )
{
	CFlexAnimationTrack *track = GetSafeTrack();
	if ( !track )
		return;

	track->SetTrackActive( state );
}

//-----------------------------------------------------------------------------
// Purpose: 
// Output : Returns true on success, false on failure.
//-----------------------------------------------------------------------------
bool TimelineItem::IsActive( void )
{
	CFlexAnimationTrack *track = GetSafeTrack();
	if ( !track )
		return false;

	return track->IsTrackActive();
}

//-----------------------------------------------------------------------------
// Purpose: 
// Output : Returns true on success, false on failure.
//-----------------------------------------------------------------------------
bool TimelineItem::IsValid( void )
{
	CFlexAnimationTrack *track = GetSafeTrack();
	if ( !track )
		return false;

	if ( track->GetNumSamples( 0 ) > 0 )
		return true;

	return false;
}

//-----------------------------------------------------------------------------
// Purpose: 
// Output : CFlexAnimationTrack
//-----------------------------------------------------------------------------
CFlexAnimationTrack *TimelineItem::GetSafeTrack( void )
{	
	if ( !g_pExpressionTool )
		return NULL;

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

	// Find track by name
	for ( int i = 0; i < ev->GetNumFlexAnimationTracks() ; i++ )
	{
		CFlexAnimationTrack *track = ev->GetFlexAnimationTrack( i );
		if ( track && !stricmp( track->GetFlexControllerName(), m_szTrackName ) )
		{
			return track;
		}
	}

	return NULL;
}

//-----------------------------------------------------------------------------
// Purpose: 
// Input  : type - 
//-----------------------------------------------------------------------------
void TimelineItem::SetEditType( int type )
{
	Assert( type == 0 || type == 1 );

	CFlexAnimationTrack *track = GetSafeTrack();
	if ( !track || !track->IsComboType() )
	{
		type = 0;
	}
	
	m_nEditType = type;
}

//-----------------------------------------------------------------------------
// Purpose: 
// Output : int
//-----------------------------------------------------------------------------
int TimelineItem::GetEditType( void )
{
	return m_nEditType;
}

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
void TimelineItem::SelectPoints( void )
{
	RECT rcSelection;
	
	rcSelection.left = m_nStartX < m_nLastX ? m_nStartX : m_nLastX;
	rcSelection.right = m_nStartX < m_nLastX ? m_nLastX : m_nStartX;

	rcSelection.top = m_nStartY < m_nLastY ? m_nStartY : m_nLastY;
	rcSelection.bottom = m_nStartY < m_nLastY ? m_nLastY : m_nStartY;

	int selW = rcSelection.right - rcSelection.left;
	int selH = rcSelection.bottom - rcSelection.top;

	float tolerance = FP_TL_SELECTION_RECTANGLE_TOLERANCE;
	// If they are just clicking and releasing in one spot, capture any items w/in a larger tolerance
	if ( selW <= 2 && selH <= 2 )
	{
		tolerance = FP_TL_SELECTION_TOLERANCE;

		CExpressionSample *sample = GetSampleUnderMouse( rcSelection.left + selW * 0.5f, rcSelection.top + selH * 0.5f );
		if ( sample )
		{
			sample->selected = true;
			return;
		}
	}
	else
	{
		InflateRect( &rcSelection, 3, 3 );
	}

	int width = m_rcBounds.right - m_rcBounds.left;
	int height = m_rcBounds.bottom - m_rcBounds.top;

	CFlexAnimationTrack *track = GetSafeTrack();
	if ( !track || !width || !height )
		return;

	CChoreoEvent *e = track->GetEvent();
	Assert( e );
	if ( !e )
		return;

	float duration = e->GetDuration();

	float fleft = (float)GetTimeForMouse( rcSelection.left + m_rcBounds.left );
	float fright = (float)GetTimeForMouse( rcSelection.right + m_rcBounds.left );

	//fleft *= duration;
	//fright *= duration;

	float ftop = (float)rcSelection.top / (float)height;
	float fbottom = (float)rcSelection.bottom / (float)height;

	fleft = clamp( fleft, 0.0f, duration );
	fright = clamp( fright, 0.0f, duration );
	ftop = clamp( ftop, 0.0f, 1.0f );
	fbottom = clamp( fbottom, 0.0f, 1.0f );

	float timestepperpixel = 1.0f / g_pExpressionTool->GetPixelsPerSecond();
	float yfracstepperpixel = 1.0f / (float)height;

	float epsx = tolerance*timestepperpixel;
	float epsy = tolerance*yfracstepperpixel;

	for ( int i = 0; i < track->GetNumSamples( m_nEditType ); i++ )
	{
		CExpressionSample *sample = track->GetSample( i, m_nEditType );
		
		if ( sample->time + epsx < fleft )
			continue;

		if ( sample->time - epsx > fright )
			continue;

		if ( (1.0f - sample->value ) + epsy < ftop )
			continue;

		if ( (1.0f - sample->value ) - epsy > fbottom )
			continue;

		sample->selected = true;
	}
}

//-----------------------------------------------------------------------------
// Purpose: 
// Input  : *undodescription - 
//-----------------------------------------------------------------------------
void TimelineItem::PreDataChanged( char const *undodescription )
{
	if ( m_nUndoSetup  == 0 )
	{
		g_pChoreoView->SetDirty( true );
		g_pChoreoView->PushUndo( undodescription );
	}
	++m_nUndoSetup;
}

//-----------------------------------------------------------------------------
// Purpose: 
// Input  : *redodescription - 
//-----------------------------------------------------------------------------
void TimelineItem::PostDataChanged( char const *redodescription )
{
	--m_nUndoSetup;
	if ( m_nUndoSetup == 0 )
	{
		g_pChoreoView->PushRedo( redodescription );
		g_pExpressionTool->InvalidateLayout();
	}
}

void TimelineItem::SetBounds( const RECT& rect )
{
	m_rcBounds = rect;
}

void TimelineItem::GetBounds( RECT& rect )
{
	rect = m_rcBounds;
}

void TimelineItem::SetVisible( bool vis )
{
	m_bVisible = vis;
}

bool TimelineItem::GetVisible( void ) const
{
	return m_bVisible;
}

int TimelineItem::GetNumSelected( void ) 
{
	return m_nNumSelected;
}

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
void TimelineItem::SnapAll()
{
	CFlexAnimationTrack *track = GetSafeTrack();
	if ( !track )
		return;

	for ( int t = 0; t < 2; t++ )
	{
		for ( int i = 0; i <  track->GetNumSamples( t ); i++ )
		{
			CExpressionSample *sample = track->GetSample( i, t );
			sample->time = FacePoser_SnapTime( sample->time );
		}
	}
}

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
void TimelineItem::SnapSelected()
{
	CFlexAnimationTrack *track = GetSafeTrack();
	if ( !track )
		return;

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

			sample->time = FacePoser_SnapTime( sample->time );
		}
	}
}

//-----------------------------------------------------------------------------
// Purpose: 
// Input  : start - 
//			end - 
//-----------------------------------------------------------------------------
void TimelineItem::DeletePoints( float start, float end )
{
	CFlexAnimationTrack *track = GetSafeTrack();
	if ( !track )
		return;

	for ( int t = 0; t < 2; t++ )
	{
		int num = track->GetNumSamples( t );
		for ( int i = num - 1; i >= 0 ; i-- )
		{
			CExpressionSample *sample = track->GetSample( i, t );
			if ( sample->time < start || sample->time > end )
				continue;

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

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
void TimelineItem::OnDoubleClicked()
{
	// Disabled for now by request of BillF
	CFlexAnimationTrack *track = GetSafeTrack();
	if ( !track )
		return;

	SetCollapsed( !IsCollapsed() );
	g_pExpressionTool->LayoutItems( true );
}

void TimelineItem::DrawEventEnd( CChoreoWidgetDrawHelper& drawHelper )
{
	CFlexAnimationTrack *track = GetSafeTrack();
	if ( !track )
		return;

	CChoreoEvent *e = track->GetEvent();
	if ( !e )
		return;

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

	int leftx = GetMouseForTime( duration );
	if ( leftx > m_rcBounds.right )
		return;

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

}

//-----------------------------------------------------------------------------
// Purpose: 
// Input  : helper - 
//			handleRect - 
//-----------------------------------------------------------------------------
void TimelineItem::DrawGrowHandle( CChoreoWidgetDrawHelper& helper, RECT& handleRect )
{
	Assert(CanHaveGrowHandle());

	RECT useRect = handleRect;
	helper.OffsetSubRect( useRect );

	POINT region[4];
	int cPoints = 4;

	region[ 0 ].x = useRect.left + GROW_HANDLE_INSETPIXELS;
	region[ 0 ].y = useRect.top;

	region[ 1 ].x = useRect.right - GROW_HANDLE_INSETPIXELS;
	region[ 1 ].y = useRect.top;

	region[ 2 ].x = useRect.right;
	region[ 2 ].y = useRect.bottom;

	region[ 3 ].x = useRect.left;
	region[ 3 ].y = useRect.bottom;

	HDC dc = helper.GrabDC();

	HRGN rgn = CreatePolygonRgn( region, cPoints, ALTERNATE );

	int oldPF = SetPolyFillMode( dc, ALTERNATE );
	
	HBRUSH brBg = CreateSolidBrush( RGB( 150, 150, 150 ) );
	HBRUSH brBorder = CreateSolidBrush( RGB( 200, 200, 200 ) );

	FillRgn( dc, rgn, brBg );
	FrameRgn( dc, rgn, brBorder, 1, 1 );

	SetPolyFillMode( dc, oldPF );

	DeleteObject( rgn );

	DeleteObject( brBg );
	DeleteObject( brBorder );

	// draw a line in the middle
	int midy = ( handleRect.bottom + handleRect.top ) * 0.5f;
	int lineinset = GROW_HANDLE_INSETPIXELS *1.5;

	helper.DrawColoredLine( RGB( 63, 63, 63 ), PS_SOLID, 1, 
		handleRect.left + lineinset, midy,
		handleRect.right - lineinset, midy );
}

//-----------------------------------------------------------------------------
// Purpose: 
// Input  : rc - 
//-----------------------------------------------------------------------------
void TimelineItem::GetGrowHandleRect( RECT& rc )
{
	rc = m_rcBounds;
	rc.bottom -= 1;
	rc.top = rc.bottom - GROW_HANDLE_HEIGHT;
	rc.left = ( rc.right + rc.left ) / 2 - GROW_HANDLE_WIDTH / 2;
	rc.right = rc.left +  GROW_HANDLE_WIDTH;
}

//-----------------------------------------------------------------------------
// Purpose: 
// Output : Returns true on success, false on failure.
//-----------------------------------------------------------------------------
bool TimelineItem::CanHaveGrowHandle()
{
	if ( IsCollapsed() )
		return false;

	if ( !g_pExpressionTool->IsFocusItem( this ) )
		return false;

	return true;
}

//-----------------------------------------------------------------------------
// Purpose: 
// Input  : x - 
//			y - 
// Output : Returns true on success, false on failure.
//-----------------------------------------------------------------------------
bool TimelineItem::IsMouseOverGrowHandle( int x, int y)
{
	if ( !CanHaveGrowHandle() )
		return false;

	RECT rcGrowHandle;
	GetGrowHandleRect( rcGrowHandle );

	POINT pt;
	pt.x = x + m_rcBounds.left;
	pt.y = y + m_rcBounds.top;

	return PtInRect( &rcGrowHandle, pt ) ? true : false;
}

void TimelineItem::DrawGrowRect()
{
	RECT rcFocus = m_rcBounds;
	rcFocus.bottom = m_rcBounds.top + m_nLastY;
	OffsetRect( &rcFocus, -m_rcBounds.left, -m_rcBounds.top );

	POINT offset;
	offset.x = m_rcBounds.left;
	offset.y = m_rcBounds.top;
	ClientToScreen( (HWND)m_pWorkspace->getHandle(), &offset );
	OffsetRect( &rcFocus, offset.x, offset.y );

	HDC dc = GetDC( NULL );

	::DrawFocusRect( dc, &rcFocus );

	ReleaseDC( NULL, dc );
}

void TimelineItem::GetWorkList( bool reflect, CUtlVector< TimelineItem * >& list )
{
	if ( !reflect )
	{
		list.AddToTail( this );
	}
	else
	{
		g_pExpressionTool->GetTimelineItems( list );
	}
}