1HEADmaster

1 files changed, 11647 insertions, 0 deletions

diff --git a/utils/hlfaceposer/choreoview.cpp b/utils/hlfaceposer/choreoview.cpp
new file mode 100644
index 0000000..440e69b
--- /dev/null
+++ b/utils/hlfaceposer/choreoview.cpp
@@ -0,0 +1,11647 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+// Purpose: 
+//
+// $NoKeywords: $
+//===========================================================================//
+#include "cbase.h"
+#include <stdio.h>
+#include <mxtk/mxWindow.h>
+#include "mdlviewer.h"
+#include "hlfaceposer.h"
+#include "StudioModel.h"
+#include "expressions.h"
+#include "expclass.h"
+#include "ChoreoView.h"
+#include "choreoevent.h"
+#include "choreoactor.h"
+#include "choreochannel.h"
+#include "choreoscene.h"
+#include "choreowidget.h"
+#include "choreoactorwidget.h"
+#include "choreochannelwidget.h"
+#include "choreoglobaleventwidget.h"
+#include "choreowidgetdrawhelper.h"
+#include "choreoeventwidget.h"
+#include "viewerSettings.h"
+#include "filesystem.h"
+#include "choreoviewcolors.h"
+#include "ActorProperties.h"
+#include "ChannelProperties.h"
+#include "EventProperties.h"
+#include "GlobalEventProperties.h"
+#include "ifaceposersound.h"
+#include "snd_wave_source.h"
+#include "ifaceposerworkspace.h"
+#include "PhonemeEditor.h"
+#include "iscenetokenprocessor.h"
+#include "InputProperties.h"
+#include "filesystem.h"
+#include "ExpressionTool.h"
+#include "ControlPanel.h"
+#include "faceposer_models.h"
+#include "choiceproperties.h"
+#include "MatSysWin.h"
+#include "tier1/strtools.h"
+#include "GestureTool.h"
+#include "npcevent.h"
+#include "RampTool.h"
+#include "SceneRampTool.h"
+#include "KeyValues.h"
+#include "SoundEmitterSystem/isoundemittersystembase.h"
+#include "cclookup.h"
+#include "iclosecaptionmanager.h"
+#include "AddSoundEntry.h"
+#include "isoundcombiner.h"
+#include <vgui/ILocalize.h>
+#include "scriplib.h"
+#include "WaveBrowser.h"
+#include "filesystem_init.h"
+#include "flexpanel.h"
+#include "tier3/choreoutils.h"
+#include "tier2/p4helpers.h"
+
+
+using namespace vgui;
+
+extern vgui::ILocalize *g_pLocalize;
+
+// 10x magnification
+#define MAX_TIME_ZOOM 1000
+#define TIME_ZOOM_STEP 4
+
+#define PHONEME_FILTER 0.08f
+#define PHONEME_DELAY  0.0f
+
+#define SCRUBBER_HEIGHT	15
+#define TIMELINE_NUMBERS_HEIGHT 11
+
+#define COPYPASTE_FILENAME	"scenes/copydatavcd.txt"
+
+extern double realtime;
+extern bool NameLessFunc( const char *const& name1, const char *const& name2 );
+
+// Try to keep shifted times at same absolute time
+static void RescaleExpressionTimes( CChoreoEvent *event, float newstart, float newend )
+{
+	if ( !event || event->GetType() != CChoreoEvent::FLEXANIMATION )
+		return;
+
+	// Did it actually change
+	if ( newstart == event->GetStartTime() &&
+		 newend == event->GetEndTime() )
+	{
+		 return;
+	}
+
+	float newduration = newend - newstart;
+
+	float dt = 0.0f;
+	//If the end is moving, leave tags stay where they are (dt == 0.0f)
+	if ( newstart != event->GetStartTime() )
+	{
+		// Otherwise, if the new start is later, then tags need to be shifted backwards
+		dt -= ( newstart - event->GetStartTime() );
+	}
+
+	int count = event->GetNumFlexAnimationTracks();
+	int i;
+
+	for ( i = 0; i < count; i++ )
+	{
+		CFlexAnimationTrack *track = event->GetFlexAnimationTrack( i );
+		if ( !track )
+			continue;
+
+		for ( int type = 0; type < 2; type++ )
+		{
+			int sampleCount = track->GetNumSamples( type );
+			for ( int sample = sampleCount - 1; sample >= 0 ; sample-- )
+			{
+				CExpressionSample *s = track->GetSample( sample, type );
+				if ( !s )
+					continue;
+
+				s->time += dt;
+
+				if ( s->time > newduration || s->time < 0.0f )
+				{
+					track->RemoveSample( sample, type );
+				}
+			}
+		}
+	}
+}
+
+static void RescaleRamp( CChoreoEvent *event, float newduration )
+{
+	float oldduration = event->GetDuration();
+
+	if ( fabs( oldduration - newduration ) < 0.000001f )
+		return;
+
+	if ( newduration <= 0.0f )
+		return;
+
+	float midpointtime = oldduration * 0.5f;
+	float newmidpointtime = newduration * 0.5f;
+
+	int count = event->GetRampCount();
+	int i;
+
+	for ( i = 0; i < count; i++ )
+	{
+		CExpressionSample *sample = event->GetRamp( i );
+		if ( !sample )
+			continue;
+
+		float t = sample->time;
+		if ( t < midpointtime )
+			continue;
+
+		float timefromend = oldduration - t;
+
+		// There's room to just shift it
+		if ( timefromend <= newmidpointtime )
+		{
+			t = newduration - timefromend;
+		}
+		else
+		{
+			// No room, rescale them instead
+			float frac = ( t - midpointtime ) / midpointtime;
+			t = newmidpointtime + frac * newmidpointtime;
+		}
+
+		sample->time = t;
+	}
+}
+
+bool DoesAnyActorHaveAssociatedModelLoaded( CChoreoScene *scene )
+{
+	if ( !scene )
+		return false;
+
+	int c = scene->GetNumActors();
+	int i;
+	for ( i = 0; i < c; i++ )
+	{
+		CChoreoActor *a = scene->GetActor( i );
+		if ( !a )
+			continue;
+
+		char const *modelname = a->GetFacePoserModelName();
+		if ( !modelname )
+			continue;
+
+		if ( !modelname[ 0 ] )
+			continue;
+
+		char mdlname[ 256 ];
+		Q_strncpy( mdlname, modelname, sizeof( mdlname ) );
+		Q_FixSlashes( mdlname );
+
+		int idx = models->FindModelByFilename( mdlname );
+		if ( idx >= 0 )
+		{
+			return true;
+		}
+	}
+
+	return false;
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+// Input  : *a - 
+// Output : StudioModel
+//-----------------------------------------------------------------------------
+StudioModel *FindAssociatedModel( CChoreoScene *scene, CChoreoActor *a )
+{
+	if ( !a || !scene )
+		return NULL;
+
+	Assert( models->GetActiveStudioModel() );
+
+	StudioModel *model = NULL;
+	if ( a->GetFacePoserModelName()[ 0 ] )
+	{
+		int idx = models->FindModelByFilename( a->GetFacePoserModelName() );
+		if ( idx >= 0 )
+		{
+			model = models->GetStudioModel( idx );
+			return model;
+		}
+	}
+
+	// Is there any loaded model with the actorname in it?
+	int c = models->Count();
+	for ( int i = 0; i < c; i++ )
+	{
+		char const *modelname = models->GetModelName( i );
+		if ( !Q_stricmp( modelname, a->GetName() ) )
+		{
+			return models->GetStudioModel( i );
+		}
+	}
+
+	// Does any actor have an associated model which is loaded
+	if ( DoesAnyActorHaveAssociatedModelLoaded( scene ) )
+	{
+		// Then return NULL here so we don't override with the default an actor who has a valid model going
+		return NULL;
+	}
+
+	// Couldn't find it and nobody else has a loaded associated model, so just use the default model
+	if ( !model )
+	{
+		model = models->GetActiveStudioModel();
+	}
+	return model;
+}
+
+
+CChoreoView		*g_pChoreoView = 0;
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+// Input  : *parent - 
+//			x - 
+//			y - 
+//			w - 
+//			h - 
+//			id - 
+//-----------------------------------------------------------------------------
+CChoreoView::CChoreoView( mxWindow *parent, int x, int y, int w, int h, int id )
+: IFacePoserToolWindow( "CChoreoView", "Choreography" ), mxWindow( parent, x, y, w, h )
+{
+	m_bRampOnly = false;
+
+	m_bForceProcess = false;
+
+	m_bSuppressLayout = true;
+
+	SetAutoProcess( true );
+
+	m_flLastMouseClickTime = -1.0f;
+	m_bProcessSequences = true;
+
+	m_flPlaybackRate	= 1.0f;
+
+	m_pScene = NULL;
+
+	m_flScrub			= 0.0f;
+	m_flScrubTarget		= 0.0f;
+
+	m_bCanDraw = false;
+
+	m_bRedoPending = false;
+	m_nUndoLevel = 0;
+
+	CChoreoEventWidget::LoadImages();
+
+	CChoreoWidget::m_pView = this;
+
+	setId( id );
+
+	m_flLastSpeedScale = 0.0f;
+	m_bResetSpeedScale = false;
+
+	m_nTopOffset = 0;
+	m_flLeftOffset = 0.0f;
+	m_nLastHPixelsNeeded = -1;
+	m_nLastVPixelsNeeded = -1;
+
+
+	m_nStartRow = 45;
+	m_nLabelWidth = 140;
+	m_nRowHeight = 35;
+
+	m_bSimulating = false;
+	m_bPaused = false;
+
+	m_bForward = true;
+
+	m_flStartTime = 0.0f;
+	m_flEndTime = 0.0f;
+	m_flFrameTime = 0.0f;
+
+	m_bAutomated		= false;
+	m_nAutomatedAction	= SCENE_ACTION_UNKNOWN;
+	m_flAutomationDelay = 0.0f;
+	m_flAutomationTime = 0.0f;
+
+	m_pVertScrollBar = new mxScrollbar( this, 0, 0, 18, 100, IDC_CHOREOVSCROLL, mxScrollbar::Vertical );
+	m_pHorzScrollBar = new mxScrollbar( this, 0, 0, 18, 100, IDC_CHOREOHSCROLL, mxScrollbar::Horizontal );
+
+	m_bLayoutIsValid = false;
+	m_flPixelsPerSecond = 150.0f;
+
+	m_btnPlay = new mxBitmapButton( this, 2, 4, 16, 16, IDC_PLAYSCENE, "gfx/hlfaceposer/play.bmp" );
+	m_btnPause = new mxBitmapButton( this, 18, 4, 16, 16, IDC_PAUSESCENE, "gfx/hlfaceposer/pause.bmp"  );
+	m_btnStop = new mxBitmapButton( this, 34, 4, 16, 16, IDC_STOPSCENE, "gfx/hlfaceposer/stop.bmp"  );
+
+	m_pPlaybackRate				= new mxSlider( this, 0, 0, 16, 16, IDC_CHOREO_PLAYBACKRATE );
+	m_pPlaybackRate->setRange( 0.0, 2.0, 40 );
+	m_pPlaybackRate->setValue( m_flPlaybackRate );
+
+	ShowButtons( false );
+
+	m_nFontSize = 12;
+
+	for ( int i = 0; i < MAX_ACTORS; i++ )
+	{
+		m_ActorExpanded[ i ].expanded = true;
+	}
+
+	SetChoreoFile( "" );
+
+	//SetFocus( (HWND)getHandle() );
+	if ( workspacefiles->GetNumStoredFiles( IWorkspaceFiles::CHOREODATA ) >= 1 )
+	{
+		LoadSceneFromFile( workspacefiles->GetStoredFile( IWorkspaceFiles::CHOREODATA, 0 ) );
+	}
+
+	ClearABPoints();
+
+	m_pClickedActor = NULL;
+	m_pClickedChannel = NULL;
+	m_pClickedEvent = NULL;
+	m_pClickedGlobalEvent = NULL;
+	m_nClickedX = 0;
+	m_nClickedY = 0;
+	m_nSelectedEvents = 0;
+	m_nClickedTag = -1;
+	m_nClickedChannelCloseCaptionButton = CChoreoChannelWidget::CLOSECAPTION_NONE;
+
+	// Mouse dragging
+	m_bDragging			= false;
+	m_xStart			= 0;
+	m_yStart			= 0;
+	m_nDragType			= DRAGTYPE_NONE;
+	m_hPrevCursor		= 0;
+
+	m_nMinX				= 0;
+	m_nMaxX				= 0;
+	m_bUseBounds		= false;
+
+	m_nScrollbarHeight	= 12;
+	m_nInfoHeight		= 30;
+
+	ClearStatusArea();
+
+	SetDirty( false );
+
+	m_bCanDraw = true;
+	m_bSuppressLayout = false;
+	m_flScrubberTimeOffset = 0.0f;
+
+	m_bShowCloseCaptionData = true;
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+// Input  : closing - 
+//-----------------------------------------------------------------------------
+bool CChoreoView::Close( void )
+{
+	if ( m_pScene && m_bDirty )
+	{
+		int retval = mxMessageBox( NULL, va( "Save changes to scene '%s'?", GetChoreoFile() ), g_appTitle, MX_MB_YESNOCANCEL );
+		if ( retval == 2 )
+		{
+			return false;
+		}
+		if ( retval == 0 )
+		{
+			Save();
+		}
+	}
+
+	if ( m_pScene )
+	{
+		UnloadScene();
+	}
+	return true;
+}
+
+bool CChoreoView::CanClose()
+{
+	if ( m_pScene )
+	{
+		workspacefiles->StartStoringFiles( IWorkspaceFiles::CHOREODATA );
+		workspacefiles->StoreFile( IWorkspaceFiles::CHOREODATA, GetChoreoFile() );
+		workspacefiles->FinishStoringFiles( IWorkspaceFiles::CHOREODATA );
+	}
+
+	if ( m_pScene && m_bDirty && !Close() )
+	{
+		return false;
+	}
+	return true;
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: Called just before window is destroyed
+//-----------------------------------------------------------------------------
+void CChoreoView::OnDelete()
+{
+	if ( m_pScene )
+	{
+		UnloadScene();
+	}
+
+	CChoreoWidget::m_pView = NULL;
+
+	CChoreoEventWidget::DestroyImages();
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+CChoreoView::~CChoreoView()
+{
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+void CChoreoView::ReportSceneClearToTools( void )
+{
+	if ( m_pScene )
+	{
+		m_pScene->ResetSimulation();
+	}
+
+	g_pPhonemeEditor->ClearEvent();
+	g_pExpressionTool->LayoutItems( true );
+	g_pExpressionTool->redraw();
+	g_pGestureTool->redraw();
+	g_pRampTool->redraw();
+	g_pSceneRampTool->redraw();
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: Find a time that's less than input on the granularity:
+// e.g., 3.01 granularity 0.05 will be 3.00, 3.05 will be 3.05
+// Input  : input - 
+//			granularity - 
+// Output : float
+//-----------------------------------------------------------------------------
+float SnapTime( float input, float granularity )
+{
+	float base = (float)(int)input;
+	float multiplier = (float)(int)( 1.0f / granularity );
+	float fracpart = input - (int)input;
+
+	fracpart *= multiplier;
+
+	fracpart = (float)(int)fracpart;
+	fracpart *= granularity;
+
+	return base + fracpart;
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+// Input  : drawHelper - 
+//			rc - 
+//			left - 
+//			right - 
+//-----------------------------------------------------------------------------
+void CChoreoView::DrawTimeLine( CChoreoWidgetDrawHelper& drawHelper, RECT& rc, float left, float right )
+{
+	RECT rcFill = m_rcTimeLine;
+	rcFill.bottom -= TIMELINE_NUMBERS_HEIGHT;
+	drawHelper.DrawFilledRect( COLOR_CHOREO_DARKBACKGROUND, rcFill );
+
+	RECT rcLabel;
+	float granularity = 0.5f / ((float)GetTimeZoom( GetToolName() ) / 100.0f);
+
+	drawHelper.DrawColoredLine( COLOR_CHOREO_TIMELINE, PS_SOLID, 1, rc.left, GetStartRow() - 1, rc.right, GetStartRow() - 1 );
+
+	float f = SnapTime( left, granularity );
+	while ( f < right )
+	{
+		float frac = ( f - left ) / ( right - left );
+		if ( frac >= 0.0f && frac <= 1.0f )
+		{
+			rcLabel.left = GetLabelWidth() + (int)( frac * ( rc.right - GetLabelWidth() ) );
+			rcLabel.bottom = GetStartRow() - 1;
+			rcLabel.top = rcLabel.bottom - 10;
+
+			if ( f != left )
+			{
+				drawHelper.DrawColoredLine( RGB( 220, 220, 240 ), PS_DOT,  1, 
+					rcLabel.left, GetStartRow(), rcLabel.left, h2() );
+			}
+
+			char sz[ 32 ];
+			sprintf( sz, "%.2f", f );
+
+			int textWidth = drawHelper.CalcTextWidth( "Arial", 9, FW_NORMAL, sz );
+
+			rcLabel.right = rcLabel.left + textWidth;
+
+			OffsetRect( &rcLabel, -textWidth / 2, 0 );
+
+			drawHelper.DrawColoredText( "Arial", 9, FW_NORMAL, COLOR_CHOREO_TEXT, rcLabel, sz );
+
+		}
+		f += granularity;
+	}
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+// Output : Returns true on success, false on failure.
+//-----------------------------------------------------------------------------
+bool CChoreoView::PaintBackground( void )
+{
+	redraw();
+	return false;
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+// Input  : drawHelper - 
+//-----------------------------------------------------------------------------
+void CChoreoView::DrawSceneABTicks( CChoreoWidgetDrawHelper& drawHelper )
+{
+	RECT rcThumb;
+
+	float scenestart = m_rgABPoints[ 0 ].active ? m_rgABPoints[ 0 ].time : 0.0f;
+	float sceneend = m_rgABPoints[ 1 ].active ? m_rgABPoints[ 1 ].time : 0.0f;
+
+	if ( scenestart )
+	{
+		int markerstart = GetPixelForTimeValue( scenestart );
+
+		rcThumb.left = markerstart - 4;
+		rcThumb.right = markerstart + 4;
+		rcThumb.top = 2 + GetCaptionHeight() + SCRUBBER_HEIGHT;
+		rcThumb.bottom = rcThumb.top + 8;
+
+		drawHelper.DrawTriangleMarker( rcThumb, COLOR_CHOREO_TICKAB );
+	}
+
+	if ( sceneend )
+	{
+		int markerend = GetPixelForTimeValue( sceneend );
+
+		rcThumb.left = markerend - 4;
+		rcThumb.right = markerend + 4;
+		rcThumb.top = 2 + GetCaptionHeight() + SCRUBBER_HEIGHT;
+		rcThumb.bottom = rcThumb.top + 8;
+
+		drawHelper.DrawTriangleMarker( rcThumb, COLOR_CHOREO_TICKAB );
+	}
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+// Input  : drawHelper - 
+//			rc - 
+//-----------------------------------------------------------------------------
+void CChoreoView::DrawRelativeTagLines( CChoreoWidgetDrawHelper& drawHelper, RECT& rc )
+{
+	if ( !m_pScene )
+		return;
+
+	RECT rcClip;
+	GetClientRect( (HWND)getHandle(), &rcClip );
+	rcClip.top = GetStartRow();
+	rcClip.bottom -= ( m_nInfoHeight + m_nScrollbarHeight );
+	rcClip.right -= m_nScrollbarHeight;
+
+	drawHelper.StartClipping( rcClip );
+
+	for ( int i = 0; i < m_SceneActors.Size(); i++ )
+	{
+		CChoreoActorWidget *a = m_SceneActors[ i ];
+		if ( !a )
+			continue;
+
+		for ( int j = 0; j < a->GetNumChannels(); j++ )
+		{
+			CChoreoChannelWidget *c = a->GetChannel( j );
+			if ( !c )
+				continue;
+
+			for ( int k = 0; k < c->GetNumEvents(); k++ )
+			{
+				CChoreoEventWidget *e = c->GetEvent( k );
+				if ( !e )
+					continue;
+
+				CChoreoEvent *event = e->GetEvent();
+				if ( !event )
+					continue;
+
+				if ( !event->IsUsingRelativeTag() )
+					continue;
+
+				// Using it, find the tag and figure out the time for it
+				CEventRelativeTag *tag = m_pScene->FindTagByName( 
+					event->GetRelativeWavName(),
+					event->GetRelativeTagName() );
+
+				if ( !tag )
+					continue;
+
+				// Found it, draw a vertical line
+				//
+				float tagtime = tag->GetStartTime();
+				
+				// Convert to pixel value
+				bool clipped = false;
+				int pixel = GetPixelForTimeValue( tagtime, &clipped );
+				if ( clipped )
+					continue;
+
+				drawHelper.DrawColoredLine( RGB( 180, 180, 220 ), PS_SOLID, 1, 
+					pixel, rcClip.top, pixel, rcClip.bottom );
+			}
+		}
+	}
+
+	drawHelper.StopClipping();
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: Draw the background markings (actor names, etc)
+// Input  : drawHelper - 
+//			rc - 
+//-----------------------------------------------------------------------------
+void CChoreoView::DrawBackground( CChoreoWidgetDrawHelper& drawHelper, RECT& rc )
+{
+	RECT rcClip;
+	GetClientRect( (HWND)getHandle(), &rcClip );
+	rcClip.top = GetStartRow();
+	rcClip.bottom -= ( m_nInfoHeight + m_nScrollbarHeight );
+	rcClip.right -= m_nScrollbarHeight;
+
+	int i;
+
+	for ( i = 0; i < m_SceneGlobalEvents.Size(); i++ )
+	{
+		CChoreoGlobalEventWidget *event = m_SceneGlobalEvents[ i ];
+		if ( event )
+		{
+			event->redraw( drawHelper );
+		}
+	}
+
+	drawHelper.StartClipping( rcClip );
+
+	for ( i = 0; i < m_SceneActors.Size(); i++ )
+	{
+		CChoreoActorWidget *actorW = m_SceneActors[ i ];
+		if ( !actorW )
+			continue;
+
+		actorW->redraw( drawHelper );
+	}
+
+	drawHelper.StopClipping();
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+void CChoreoView::redraw() 
+{
+	if ( !ToolCanDraw() )
+		return;
+
+	if ( m_bSuppressLayout )
+		return;
+
+	LayoutScene();
+
+	CChoreoWidgetDrawHelper drawHelper( this, COLOR_CHOREO_BACKGROUND );
+	HandleToolRedraw( drawHelper );
+
+	if ( !m_bCanDraw )
+		return;
+
+	RECT rc;
+	rc.left = 0;
+	rc.top = GetCaptionHeight();
+	rc.right = drawHelper.GetWidth();
+	rc.bottom = drawHelper.GetHeight();
+
+	RECT rcInfo;
+	rcInfo.left = rc.left;
+	rcInfo.right = rc.right - m_nScrollbarHeight;
+	rcInfo.bottom = rc.bottom - m_nScrollbarHeight;
+	rcInfo.top = rcInfo.bottom - m_nInfoHeight;
+
+	drawHelper.StartClipping( rcInfo );
+
+	RedrawStatusArea( drawHelper, rcInfo );
+
+	drawHelper.StopClipping();
+
+	RECT rcClip = rc;
+	rcClip.bottom -= ( m_nInfoHeight + m_nScrollbarHeight );
+
+	drawHelper.StartClipping( rcClip );
+
+	if ( !m_pScene )
+	{
+		char sz[ 256 ];
+		sprintf( sz, "No choreography scene file (.vcd) loaded" );
+
+		int pointsize = 18;
+		int textlen = drawHelper.CalcTextWidth( "Arial", pointsize, FW_NORMAL, sz );
+
+		RECT rcText;
+		rcText.top = ( rc.bottom - rc.top ) / 2 - pointsize / 2;
+		rcText.bottom = rcText.top + pointsize + 10;
+		rcText.left = rc.right / 2 - textlen / 2;
+		rcText.right = rcText.left + textlen;
+
+		drawHelper.DrawColoredText( "Arial", pointsize, FW_NORMAL, COLOR_CHOREO_LIGHTTEXT, rcText, sz );
+
+		drawHelper.StopClipping();
+		return;
+	}
+
+	DrawTimeLine( drawHelper, rc, m_flStartTime, m_flEndTime );
+
+	bool clipped = false;
+	int finishx = GetPixelForTimeValue( m_pScene->FindStopTime(), &clipped );
+	if ( !clipped )
+	{
+		drawHelper.DrawColoredLine( COLOR_CHOREO_ENDTIME, PS_DOT, 1, finishx, rc.top + GetStartRow(), finishx, rc.bottom );
+	}
+
+	DrawRelativeTagLines( drawHelper, rc );
+	DrawBackground( drawHelper, rc );
+
+	DrawSceneABTicks( drawHelper );
+
+	drawHelper.StopClipping();
+
+	if ( m_UndoStack.Size() > 0 )
+	{
+		int length = drawHelper.CalcTextWidth( "Arial", 9, FW_NORMAL, 
+			"undo %i/%i", m_nUndoLevel, m_UndoStack.Size() );
+		RECT rcText = rc;
+		rcText.top = rc.top + 48;
+		rcText.bottom = rcText.top + 10;
+		rcText.left = GetLabelWidth() - length - 20;
+		rcText.right = rcText.left + length;
+
+		drawHelper.DrawColoredText( "Arial", 9, FW_NORMAL, RGB( 100, 180, 100 ), rcText,
+			"undo %i/%i", m_nUndoLevel, m_UndoStack.Size() );
+	}
+
+	DrawScrubHandle( drawHelper );
+
+	char sz[ 48 ];
+	sprintf( sz, "Speed: %.2fx", m_flPlaybackRate );
+
+	int fontsize = 9;
+
+	int length = drawHelper.CalcTextWidth( "Arial", fontsize, FW_NORMAL, sz);
+	
+	RECT rcText = rc;
+	rcText.top = rc.top + 25;
+	rcText.bottom = rcText.top + 10;
+	rcText.left = GetLabelWidth() + 20;
+	rcText.right = rcText.left + length;
+
+	drawHelper.DrawColoredText( "Arial", fontsize, FW_NORMAL, 
+		RGB( 50, 50, 50 ), rcText, sz );
+
+	sprintf( sz, "Zoom: %.2fx", (float)GetTimeZoom( GetToolName() ) / 100.0f );
+
+	length = drawHelper.CalcTextWidth( "Arial", fontsize, FW_NORMAL, sz);
+
+	rcText = rc;
+	rcText.left = 5;
+	rcText.top = rc.top + 48;
+	rcText.bottom = rcText.top + 10;
+	rcText.right = rcText.left + length;
+
+	drawHelper.DrawColoredText( "Arial", fontsize, FW_NORMAL, 
+		RGB( 50, 50, 50 ), rcText, sz );
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+// Input  : current - 
+//			number - 
+// Output : int
+//-----------------------------------------------------------------------------
+void CChoreoView::GetUndoLevels( int& current, int& number )
+{
+	current = m_nUndoLevel;
+	number	= m_UndoStack.Size();
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+// Input  : time - 
+//			*clipped - 
+// Output : int
+//-----------------------------------------------------------------------------
+int CChoreoView::GetPixelForTimeValue( float time, bool *clipped /*=NULL*/ )
+{
+	if ( clipped )
+	{
+		*clipped = false;
+	}
+
+	float frac = ( time - m_flStartTime ) / ( m_flEndTime - m_flStartTime );
+	if ( frac < 0.0 || frac > 1.0 )
+	{
+		if ( clipped )
+		{
+			*clipped = true;
+		}
+	}
+
+	int pixel = GetLabelWidth() + (int)( frac * ( w2() - GetLabelWidth() ) );
+	return pixel;
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+// Input  : mx - 
+//			clip - 
+// Output : float
+//-----------------------------------------------------------------------------
+float CChoreoView::GetTimeValueForMouse( int mx, bool clip /*=false*/)
+{
+	RECT rc = m_rcTimeLine;
+	rc.left = GetLabelWidth();
+
+	if ( clip )
+	{
+		if ( mx < rc.left )
+		{
+			return m_flStartTime;
+		}
+		if ( mx > rc.right )
+		{
+			return m_flEndTime;
+		}
+	}
+
+	float frac = (float)( mx - rc.left )  / (float)( rc.right - rc.left );
+
+	return m_flStartTime + frac * ( m_flEndTime - m_flStartTime );
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+// Input  : time - 
+//-----------------------------------------------------------------------------
+void CChoreoView::SetStartTime( float time )
+{
+	m_flStartTime = time;
+	InvalidateLayout();
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+// Output : float
+//-----------------------------------------------------------------------------
+float CChoreoView::GetStartTime( void )
+{
+	return m_flStartTime;
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+// Output : float
+//-----------------------------------------------------------------------------
+float CChoreoView::GetEndTime( void )
+{
+	return m_flEndTime;
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+// Output : float
+//-----------------------------------------------------------------------------
+float CChoreoView::GetPixelsPerSecond( void )
+{
+	return m_flPixelsPerSecond * (float)GetTimeZoom( GetToolName() ) / 100.0f;
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+// Input  : mx - 
+//			origmx - 
+// Output : float
+//-----------------------------------------------------------------------------
+float CChoreoView::GetTimeDeltaForMouseDelta( int mx, int origmx )
+{
+	float t1, t2;
+
+	t2 = GetTimeValueForMouse( mx );
+	t1 = GetTimeValueForMouse( origmx );
+
+	return t2 - t1;
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+// Input  : mx - 
+//-----------------------------------------------------------------------------
+void CChoreoView::PlaceABPoint( int mx )
+{
+	m_rgABPoints[ ( m_nCurrentABPoint) & 0x01 ].time = GetTimeValueForMouse( mx );
+	m_rgABPoints[ ( m_nCurrentABPoint) & 0x01 ].active = true;
+	m_nCurrentABPoint++;
+
+	if ( m_rgABPoints[ 0 ].active && m_rgABPoints	[ 1 ].active && 
+		 m_rgABPoints[ 0 ].time > m_rgABPoints[ 1 ].time )
+	{
+		float temp = m_rgABPoints[ 0 ].time;
+		m_rgABPoints[ 0 ].time = m_rgABPoints[ 1 ].time;
+		m_rgABPoints[ 1 ].time = temp;
+	}
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+void CChoreoView::ClearABPoints( void )
+{
+	memset( m_rgABPoints, 0, sizeof( m_rgABPoints ) );
+	m_nCurrentABPoint = 0;
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+// Input  : mx - 
+//			my - 
+// Output : Returns true on success, false on failure.
+//-----------------------------------------------------------------------------
+bool CChoreoView::IsMouseOverTimeline( int mx, int my )
+{
+	POINT pt;
+	pt.x = mx;
+	pt.y = my;
+
+	RECT rcCheck = m_rcTimeLine;
+	rcCheck.bottom -= TIMELINE_NUMBERS_HEIGHT;
+
+	if ( PtInRect( &rcCheck, pt ) )
+		return true;
+
+	return false;
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+// Input  : mx - 
+//			my - 
+//-----------------------------------------------------------------------------
+void CChoreoView::ShowContextMenu( int mx, int my )
+{
+	CChoreoActorWidget		*a = NULL;
+	CChoreoChannelWidget	*c = NULL;
+	CChoreoEventWidget		*e = NULL;
+	CChoreoGlobalEventWidget *ge = NULL;
+	int						ct = -1;
+	CEventAbsoluteTag		*at = NULL;
+	int						clickedCloseCaptionButton = CChoreoChannelWidget::CLOSECAPTION_NONE;
+
+	GetObjectsUnderMouse( mx, my, &a, &c, &e, &ge, &ct, &at, &clickedCloseCaptionButton );
+	
+	m_pClickedActor			= a;
+	m_pClickedChannel		= c;
+	m_pClickedEvent			= e;
+	m_pClickedGlobalEvent	= ge;
+	m_nClickedX				= mx;
+	m_nClickedY				= my;
+	m_nClickedTag			= ct;
+	m_pClickedAbsoluteTag	= at;
+	m_nClickedChannelCloseCaptionButton = clickedCloseCaptionButton;
+
+	// Construct main
+	mxPopupMenu *pop = new mxPopupMenu();
+
+	if ( a && c )
+	{
+		if (!e)
+		{
+			pop->add( "Expression...", IDC_ADDEVENT_EXPRESSION );
+			pop->add( "WAV File...", IDC_ADDEVENT_SPEAK );
+			pop->add( "Gesture...", IDC_ADDEVENT_GESTURE );
+			pop->add( "NULL Gesture...", IDC_ADDEVENT_NULLGESTURE );
+			pop->add( "Look at actor...", IDC_ADDEVENT_LOOKAT );
+			pop->add( "Move to actor...", IDC_ADDEVENT_MOVETO );
+			pop->add( "Face actor...", IDC_ADDEVENT_FACE );
+			pop->add( "Fire Trigger...", IDC_ADDEVENT_FIRETRIGGER );
+			pop->add( "Generic(AI)...", IDC_ADDEVENT_GENERIC );
+			pop->add( "Sequence...", IDC_ADDEVENT_SEQUENCE );
+			pop->add( "Flex animation...", IDC_ADDEVENT_FLEXANIMATION );
+			pop->add( "Sub-scene...", IDC_ADDEVENT_SUBSCENE );
+			pop->add( "Interrupt...", IDC_ADDEVENT_INTERRUPT );
+			pop->add( "Permit Responses...", IDC_ADDEVENT_PERMITRESPONSES );
+
+			pop->addSeparator();
+		}
+		else
+		{
+			pop->add( va( "Edit Event '%s'...", e->GetEvent()->GetName() ), IDC_EDITEVENT );
+			switch ( e->GetEvent()->GetType() )
+			{
+			default:
+				break;
+			case CChoreoEvent::FLEXANIMATION:
+				{
+					pop->add( va( "Edit Event '%s' in expression tool", e->GetEvent()->GetName() ), IDC_EXPRESSIONTOOL );
+				}
+				break;
+			case CChoreoEvent::GESTURE:
+				{
+					pop->add( va( "Edit Event '%s' in gesture tool", e->GetEvent()->GetName() ), IDC_GESTURETOOL );
+				}
+				break;
+			}
+
+			if ( e->GetEvent()->HasEndTime() )
+			{
+				pop->add( "Timing Tag...", IDC_ADDTIMINGTAG );
+			}
+
+			pop->addSeparator();
+		}
+	}
+
+	// Construct "New..."
+	mxPopupMenu *newMenu = new mxPopupMenu();
+	{
+		newMenu->add( "Actor...", IDC_ADDACTOR );
+		if ( a )
+		{
+			newMenu->add( "Channel...", IDC_ADDCHANNEL );
+		}
+		newMenu->add( "Section Pause...", IDC_ADDEVENT_PAUSE );
+		newMenu->add( "Loop...", IDC_ADDEVENT_LOOP );
+		newMenu->add( "Fire Completion...", IDC_ADDEVENT_STOPPOINT );
+	}
+	pop->addMenu( "New", newMenu );
+
+	// Now construct "Edit..."
+	if ( a || c || e || ge )
+	{
+		mxPopupMenu	*editMenu = new mxPopupMenu();
+		{
+			if ( a )
+			{
+				editMenu->add( va( "Actor '%s'...", a->GetActor()->GetName() ), IDC_EDITACTOR );
+			}
+			if ( c )
+			{
+				editMenu->add( va( "Channel '%s'...", c->GetChannel()->GetName() ), IDC_EDITCHANNEL );
+			}
+			if ( ge )
+			{
+				switch ( ge->GetEvent()->GetType() )
+				{
+				default:
+					break;
+				case CChoreoEvent::SECTION:
+					{
+						editMenu->add( va( "Section Pause '%s'...", ge->GetEvent()->GetName() ), IDC_EDITGLOBALEVENT );
+					}
+					break;
+				case CChoreoEvent::LOOP:
+					{
+						editMenu->add( va( "Loop Point '%s'...", ge->GetEvent()->GetName() ), IDC_EDITGLOBALEVENT );
+					}
+					break;
+				case CChoreoEvent::STOPPOINT:
+					{
+						editMenu->add( va( "Fire Completion '%s'...", ge->GetEvent()->GetName() ), IDC_EDITGLOBALEVENT );
+					}
+					break;
+				}
+			}
+		}
+
+		pop->addMenu( "Edit", editMenu );
+
+	}
+
+	// Move up/down
+	if ( a || c )
+	{
+		mxPopupMenu	*moveUpMenu = new mxPopupMenu();
+		mxPopupMenu	*moveDownMenu = new mxPopupMenu();
+
+		if ( a )
+		{
+			moveUpMenu->add( va( "Move '%s' up", a->GetActor()->GetName() ), IDC_MOVEACTORUP );
+			moveDownMenu->add( va( "Move '%s' down", a->GetActor()->GetName() ), IDC_MOVEACTORDOWN );
+		}
+		if ( c )
+		{
+			moveUpMenu->add( va( "Move '%s' up", c->GetChannel()->GetName() ), IDC_MOVECHANNELUP );
+			moveDownMenu->add( va( "Move '%s' down", c->GetChannel()->GetName() ), IDC_MOVECHANNELDOWN );
+		}
+
+		pop->addMenu( "Move Up", moveUpMenu );
+		pop->addMenu( "Move Down", moveDownMenu );
+	}
+
+	// Delete
+	if ( a || c || e || ge || (ct != -1) )
+	{
+		mxPopupMenu *deleteMenu = new mxPopupMenu();
+		if ( a )
+		{
+			deleteMenu->add( va( "Actor '%s'", a->GetActor()->GetName() ), IDC_DELETEACTOR );
+		}
+		if ( c )
+		{
+			deleteMenu->add( va( "Channel '%s'", c->GetChannel()->GetName() ), IDC_DELETECHANNEL );
+		}
+		if ( e )
+		{
+			deleteMenu->add( va( "Event '%s'", e->GetEvent()->GetName() ), IDC_DELETEEVENT );
+		}
+		if ( ge )
+		{
+			switch ( ge->GetEvent()->GetType() )
+			{
+			default:
+				break;
+			case CChoreoEvent::SECTION:
+				{
+					deleteMenu->add( va( "Section Pause '%s'...", ge->GetEvent()->GetName() ), IDC_DELETEGLOBALEVENT );
+				}
+				break;
+			case CChoreoEvent::LOOP:
+				{
+					deleteMenu->add( va( "Loop Point '%s'...", ge->GetEvent()->GetName() ), IDC_DELETEGLOBALEVENT );
+				}
+				break;
+			case CChoreoEvent::STOPPOINT:
+				{
+					deleteMenu->add( va( "Fire Completion '%s'...", ge->GetEvent()->GetName() ), IDC_DELETEGLOBALEVENT );
+				}
+				break;
+			}
+		}
+		if ( e && ct != -1 )
+		{
+			CEventRelativeTag *tag = e->GetEvent()->GetRelativeTag( ct );
+			if ( tag )
+			{
+				deleteMenu->add( va( "Relative Tag '%s'...", tag->GetName() ), IDC_DELETERELATIVETAG );
+			}
+		}
+		pop->addMenu( "Delete", deleteMenu );
+	}
+
+	// Select
+	{
+		mxPopupMenu *selectMenu = new mxPopupMenu();
+		selectMenu->add( "Select All", IDC_SELECTALL );
+		selectMenu->add( "Deselect All", IDC_DESELECTALL );
+		selectMenu->addSeparator();
+
+		selectMenu->add( "All events before", IDC_SELECTEVENTS_ALL_BEFORE );
+		selectMenu->add( "All events after", IDC_SELECTEVENTS_ALL_AFTER );
+		selectMenu->add( "Active events before", IDC_SELECTEVENTS_ACTIVE_BEFORE );
+		selectMenu->add( "Active events after", IDC_SELECTEVENTS_ACTIVE_AFTER );
+		selectMenu->add( "Channel events before", IDC_SELECTEVENTS_CHANNEL_BEFORE );
+		selectMenu->add( "Channel events after", IDC_SELECTEVENTS_CHANNEL_AFTER );
+
+		if ( a || c )
+		{
+			selectMenu->addSeparator();
+			if ( a )
+			{
+				selectMenu->add( va( "All events in actor '%s'", a->GetActor()->GetName() ), IDC_CV_ALLEVENTS_ACTOR );
+			}
+			if ( c )
+			{
+				selectMenu->add( va( "All events in channel '%s'", c->GetChannel()->GetName() ), IDC_CV_ALLEVENTS_CHANNEL );
+			}
+		}
+		pop->addMenu( "Select/Deselect", selectMenu );
+	}
+
+	// Quick delete for events
+	if ( e )
+	{
+		pop->addSeparator();
+
+		switch ( e->GetEvent()->GetType() )
+		{
+		default:
+			break;
+		case CChoreoEvent::FLEXANIMATION:
+			{
+				pop->add( va( "Edit event '%s' in expression tool", e->GetEvent()->GetName() ), IDC_EXPRESSIONTOOL );
+			}
+			break;
+		case CChoreoEvent::GESTURE:
+			{
+				pop->add( va( "Edit event '%s' in gesture tool", e->GetEvent()->GetName() ), IDC_GESTURETOOL );
+			}
+			break;
+		}
+
+		pop->add( va( "Move event '%s' to back", e->GetEvent()->GetName() ), IDC_MOVETOBACK );
+		if ( CountSelectedEvents() > 1 )
+		{
+			pop->add( va( "Delete events" ), IDC_DELETEEVENT );
+			pop->addSeparator();
+			pop->add( "Enable events", IDC_CV_ENABLEEVENTS );
+			pop->add( "Disable events", IDC_CV_DISABLEEVENTS );
+		}
+		else
+		{
+			pop->add( va( "Delete event '%s'", e->GetEvent()->GetName() ), IDC_DELETEEVENT );
+			pop->addSeparator();
+			if ( e->GetEvent()->GetActive() )
+			{
+				pop->add( va( "Disable event '%s'", e->GetEvent()->GetName() ), IDC_CV_DISABLEEVENTS );
+			}
+			else
+			{
+				pop->add( va( "Enable event '%s'", e->GetEvent()->GetName() ), IDC_CV_ENABLEEVENTS );
+			}
+		}
+	}
+
+	if ( m_rgABPoints[ 0 ].active && m_rgABPoints[ 1 ].active  )
+	{
+		pop->addSeparator();
+		mxPopupMenu *timeMenu = new mxPopupMenu();
+		timeMenu->add( "Insert empty space between marks (shifts events right)", IDC_INSERT_TIME );
+		timeMenu->add( "Delete events between marks (shifts remaining events left)", IDC_DELETE_TIME );
+		pop->addMenu( "Time Marks", timeMenu );
+	}
+
+
+	// Copy/paste
+	if ( CanPaste() || e )
+	{
+		pop->addSeparator();
+
+		if ( CountSelectedEvents() > 1 )
+		{
+			pop->add( va( "Copy events to clipboard" ), IDC_COPYEVENTS );
+		}
+		else if ( e )
+		{
+			pop->add( va( "Copy event '%s' to clipboard", e->GetEvent()->GetName() ), IDC_COPYEVENTS );
+		}
+
+		if ( CanPaste() )
+		{
+			pop->add( va( "Paste events" ), IDC_PASTEEVENTS );
+		}
+	}
+
+	// Export / import
+	pop->addSeparator();
+
+	if ( e )
+	{
+		mxPopupMenu *exportMenu = new mxPopupMenu();
+		if ( CountSelectedEvents() > 1 )
+		{
+			exportMenu->add( va( "Export events to .vce..." ), IDC_EXPORTEVENTS );
+		}
+		else if ( e )
+		{
+			exportMenu->add( va( "Export event '%s' to .vce...", e->GetEvent()->GetName() ), IDC_EXPORTEVENTS );
+		}
+		exportMenu->add( va( "Export as .vcd..." ), IDC_EXPORT_VCD );
+		pop->addMenu( "Export", exportMenu );
+	}
+
+	mxPopupMenu *importMenu = new mxPopupMenu();
+	importMenu->add( va( "Import events from .vce..." ), IDC_IMPORTEVENTS );
+	importMenu->add( va( "Merge from .vcd..." ), IDC_IMPORT_VCD );
+	pop->addMenu( "Import", importMenu );
+
+	bool bShowAlignLeft = ( CountSelectedEvents() + CountSelectedGlobalEvents() ) > 1 ? true : false;
+
+	if ( e && ( ( CountSelectedEvents() > 1 ) || bShowAlignLeft ) )
+	{
+		pop->addSeparator();
+
+		mxPopupMenu *alignMenu = new mxPopupMenu();
+		alignMenu->add( "Align Left", IDC_CV_ALIGN_LEFT );
+		if ( CountSelectedEvents() > 1 )
+		{
+			alignMenu->add( "Align Right", IDC_CV_ALIGN_RIGHT );
+			alignMenu->add( "Size to Smallest", IDC_CV_SAMESIZE_SMALLEST );
+			alignMenu->add( "Size to Largest", IDC_CV_SAMESIZE_LARGEST );
+		}
+		pop->addMenu( "Align", alignMenu );
+	}
+
+	// Misc.
+	pop->addSeparator();
+	pop->add( va( "Change scale..." ), IDC_CV_CHANGESCALE );
+	pop->add( va( "Check sequences" ), IDC_CV_CHECKSEQLENGTHS );
+	pop->add( va( "Process sequences" ), IDC_CV_PROCESSSEQUENCES );
+	pop->add( va( m_bRampOnly ? "Ramp normal" : "Ramp only" ), IDC_CV_TOGGLERAMPONLY );
+	pop->setChecked( IDC_CV_PROCESSSEQUENCES, m_bProcessSequences );
+
+	bool onmaster= ( m_pClickedChannel && 
+			m_pClickedChannel->GetCaptionClickedEvent() &&
+			m_pClickedChannel->GetCaptionClickedEvent()->GetCloseCaptionType() == CChoreoEvent::CC_MASTER ) ? true : false;
+	bool ondisabled = ( m_pClickedChannel && 
+			m_pClickedChannel->GetCaptionClickedEvent() &&
+			m_pClickedChannel->GetCaptionClickedEvent()->GetCloseCaptionType() == CChoreoEvent::CC_DISABLED ) ? true : false;
+
+	// The close captioning menu
+	if ( m_bShowCloseCaptionData && ( AreSelectedEventsCombinable() || AreSelectedEventsInSpeakGroup() || onmaster || ondisabled ) )
+	{
+		pop->addSeparator();
+		if ( AreSelectedEventsCombinable() )
+		{
+			pop->add( "Combine Speak Events", IDC_CV_COMBINESPEAKEVENTS );
+		}
+		if ( AreSelectedEventsInSpeakGroup() )
+		{
+			pop->add( "Uncombine Speak Events", IDC_CV_REMOVESPEAKEVENTFROMGROUP );
+		}
+		if ( onmaster )
+		{
+			// Can only change tokens for "combined" files
+			if ( m_pClickedChannel->GetCaptionClickedEvent()->GetNumSlaves() >= 1 )
+			{
+				pop->add( "Change Token", IDC_CV_CHANGECLOSECAPTIONTOKEN );
+			}
+			pop->add( "Disable captions", IDC_CV_TOGGLECLOSECAPTIONS );
+		}
+		if ( ondisabled )
+		{
+			pop->add( "Enable captions", IDC_CV_TOGGLECLOSECAPTIONS );
+		}
+	}
+
+	// Undo/redo
+	if ( CanUndo() || CanRedo() )
+	{
+
+		pop->addSeparator();
+
+		if ( CanUndo() )
+		{
+			pop->add( va( "Undo %s", GetUndoDescription() ), IDC_CVUNDO );
+		}
+		if ( CanRedo() )
+		{
+			pop->add( va( "Redo %s", GetRedoDescription() ), IDC_CVREDO );
+		}
+	}
+
+	if ( m_pScene )
+	{
+		// Associate map file
+		pop->addSeparator();
+		pop->add( va( "Associate .bsp (%s)", m_pScene->GetMapname() ), IDC_ASSOCIATEBSP );
+		if ( a )
+		{
+			if ( a->GetActor() && a->GetActor()->GetFacePoserModelName()[0] )
+			{
+				pop->add( va( "Change .mdl for %s", a->GetActor()->GetName() ), IDC_ASSOCIATEMODEL );
+			}
+			else
+			{
+				pop->add( va( "Associate .mdl with %s", a->GetActor()->GetName() ), IDC_ASSOCIATEMODEL );
+			}
+		}
+	}
+
+	pop->popup( this, mx, my );
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+void CChoreoView::AssociateModel( void )
+{
+	if ( !m_pScene )
+		return;
+
+	CChoreoActorWidget *actor = m_pClickedActor;
+	if ( !actor )
+		return;
+
+	CChoreoActor *a = actor->GetActor();
+	if ( !a )
+		return;
+
+	CChoiceParams params;
+	strcpy( params.m_szDialogTitle, "Associate Model" );
+
+	params.m_bPositionDialog = false;
+	params.m_nLeft = 0;
+	params.m_nTop = 0;
+	strcpy( params.m_szPrompt, "Choose model:" );
+
+	params.m_Choices.RemoveAll();
+
+	params.m_nSelected = -1;
+	int oldsel = -1;
+
+	int c = models->Count();
+	ChoiceText text;
+	for ( int i = 0; i < c; i++ )
+	{
+		char const *modelname = models->GetModelName( i );
+
+		strcpy( text.choice, modelname );
+
+		if ( !stricmp( a->GetName(), modelname ) )
+		{
+			params.m_nSelected = i;
+			oldsel = -1;
+		}
+
+		params.m_Choices.AddToTail( text );
+	}
+
+	// Add an extra entry which is "No association"
+	strcpy( text.choice, "No Associated Model" );
+	params.m_Choices.AddToTail( text );
+
+	if ( !ChoiceProperties( &params ) )
+		return;
+	
+	if ( params.m_nSelected == oldsel )
+		return;
+
+	// Chose something new...
+	if ( params.m_nSelected >= 0 &&
+		 params.m_nSelected < params.m_Choices.Count() )
+	{
+		AssociateModelToActor( a, params.m_nSelected );
+	}
+	else
+	{
+		// Chose "No association"
+		AssociateModelToActor( a, -1 );
+	}
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+// Input  : *actor - 
+//			modelindex - 
+//-----------------------------------------------------------------------------
+void CChoreoView::AssociateModelToActor( CChoreoActor *actor, int modelindex )
+{
+	Assert( actor );
+
+	SetDirty( true );
+
+	PushUndo( "Associate model" );
+
+	// Chose something new...
+	if ( modelindex >= 0 &&
+		 modelindex < models->Count() )
+	{
+		actor->SetFacePoserModelName( models->GetModelFileName( modelindex ) );
+	}
+	else
+	{
+		// Chose "No Associated Model"
+		actor->SetFacePoserModelName( "" );
+	}
+
+	RecomputeWaves();
+
+	PushRedo( "Associate model" );
+}
+
+void CChoreoView::AssociateBSP( void )
+{
+	if ( !m_pScene )
+		return;
+
+	// Strip game directory and slash
+	char mapname[ 512 ];
+	if ( !FacePoser_ShowOpenFileNameDialog( mapname, sizeof( mapname ), "maps", "*.bsp" ) )
+	{
+		return;
+	}
+	
+	m_pScene->SetMapname( mapname );
+	redraw();
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+void CChoreoView::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 );
+}
+
+int CChoreoView::GetSelectedEventWidgets( CUtlVector< CChoreoEventWidget * >& events )
+{
+	events.RemoveAll();
+
+	int c = 0;
+
+	for ( int i = 0; i < m_SceneActors.Size(); i++ )
+	{
+		CChoreoActorWidget *actor = m_SceneActors[ i ];
+		if ( !actor )
+			continue;
+
+		for ( int j = 0; j < actor->GetNumChannels(); j++ )
+		{
+			CChoreoChannelWidget *channel = actor->GetChannel( j );
+			if ( !channel )
+				continue;
+
+			for ( int k = 0; k < channel->GetNumEvents(); k++ )
+			{
+				CChoreoEventWidget *event = channel->GetEvent( k );
+				if ( !event )
+					continue;
+
+				if ( event->IsSelected() )
+				{
+					events.AddToTail( event );
+					c++;
+				}
+			}
+		}
+	}
+
+	return c;
+}
+
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+// Input  : events - 
+// Output : int
+//-----------------------------------------------------------------------------
+int CChoreoView::GetSelectedEvents( CUtlVector< CChoreoEvent * >& events )
+{
+	events.RemoveAll();
+
+	int c = 0;
+
+	for ( int i = 0; i < m_SceneActors.Size(); i++ )
+	{
+		CChoreoActorWidget *actor = m_SceneActors[ i ];
+		if ( !actor )
+			continue;
+
+		for ( int j = 0; j < actor->GetNumChannels(); j++ )
+		{
+			CChoreoChannelWidget *channel = actor->GetChannel( j );
+			if ( !channel )
+				continue;
+
+			for ( int k = 0; k < channel->GetNumEvents(); k++ )
+			{
+				CChoreoEventWidget *event = channel->GetEvent( k );
+				if ( !event )
+					continue;
+
+				if ( event->IsSelected() )
+				{
+					events.AddToTail( event->GetEvent() );
+					c++;
+				}
+			}
+		}
+	}
+
+	return c;
+}
+
+int CChoreoView::CountSelectedGlobalEvents( void )
+{
+	int c = 0;
+	for ( int i = 0; i < m_SceneGlobalEvents.Size(); i++ )
+	{
+		CChoreoGlobalEventWidget *event = m_SceneGlobalEvents[ i ];
+		if ( !event || !event->IsSelected() )
+			continue;
+
+		++c;
+	}
+	return c;
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+// Output : int
+//-----------------------------------------------------------------------------
+int CChoreoView::CountSelectedEvents( void )
+{
+	int c = 0;
+
+	for ( int i = 0; i < m_SceneActors.Size(); i++ )
+	{
+		CChoreoActorWidget *actor = m_SceneActors[ i ];
+		if ( !actor )
+			continue;
+
+		for ( int j = 0; j < actor->GetNumChannels(); j++ )
+		{
+			CChoreoChannelWidget *channel = actor->GetChannel( j );
+			if ( !channel )
+				continue;
+
+			for ( int k = 0; k < channel->GetNumEvents(); k++ )
+			{
+				CChoreoEventWidget *event = channel->GetEvent( k );
+				if ( !event )
+					continue;
+
+				if ( event->IsSelected() )
+					c++;
+
+			}
+		}
+	}
+
+	return c;
+}
+
+bool CChoreoView::IsMouseOverEvent( CChoreoEventWidget *ew, int mx, int my )
+{
+	int tolerance = DRAG_EVENT_EDGE_TOLERANCE;
+
+	RECT bounds = ew->getBounds();
+	mx -= bounds.left;
+	my -= bounds.top;
+
+	if ( mx <= -tolerance )
+	{
+		return false;
+	}
+
+	CChoreoEvent *event = ew->GetEvent();
+	if ( event )
+	{
+		if ( event->HasEndTime() )
+		{
+			int rightside = ew->GetDurationRightEdge() ? ew->GetDurationRightEdge() : ew->w();
+
+			if ( mx > rightside + tolerance )
+			{
+				return false;
+			}
+		}
+	}
+
+	return true;
+}
+
+
+bool CChoreoView::IsMouseOverEventEdge( CChoreoEventWidget *ew, bool bLeftEdge, int mx, int my )
+{
+	int tolerance = DRAG_EVENT_EDGE_TOLERANCE;
+
+	RECT bounds = ew->getBounds();
+	mx -= bounds.left;
+	my -= bounds.top;
+
+	CChoreoEvent *event = ew->GetEvent();
+	if ( event && event->HasEndTime() )
+	{
+		if ( mx > -tolerance && mx <= tolerance )
+		{
+			return bLeftEdge;
+		}
+
+		int rightside = ew->GetDurationRightEdge() ? ew->GetDurationRightEdge() : ew->w();
+
+		if ( mx >= rightside - tolerance )
+		{
+			if ( mx > rightside + tolerance )
+			{
+				return false;
+			}
+			else
+			{
+				return !bLeftEdge;
+			}
+		}
+	}
+
+	return false;
+}
+
+int CChoreoView::GetEarliestEventIndex( CUtlVector< CChoreoEventWidget * >& events )
+{
+	int best = -1;
+	float minTime = FLT_MAX;
+
+	int c = events.Count();
+	for ( int i = 0; i < c; ++i )
+	{
+		CChoreoEvent *e = events[ i ]->GetEvent();
+		float t = e->GetStartTime();
+		if ( t < minTime )
+		{
+			minTime = t;
+			best = i;
+		}
+	}
+
+	return best;
+}
+
+int	 CChoreoView::GetLatestEventIndex( CUtlVector< CChoreoEventWidget * >& events )
+{
+	int best = -1;
+	float maxTime = FLT_MIN;
+
+	int c = events.Count();
+	for ( int i = 0; i < c; ++i )
+	{
+		CChoreoEvent *e = events[ i ]->GetEvent();
+		float t = e->GetEndTime();
+		if ( t > maxTime )
+		{
+			maxTime = t;
+			best = i;
+		}
+	}
+
+	return best;
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+// Input  : mx - 
+// Output : int
+//-----------------------------------------------------------------------------
+int CChoreoView::ComputeEventDragType( int mx, int my )
+{
+	int tolerance = DRAG_EVENT_EDGE_TOLERANCE;
+
+	// Iterate the events and see who's closest
+	CChoreoEventWidget *ew = GetEventUnderCursorPos( mx, my );
+	if ( !ew )
+	{
+		return DRAGTYPE_NONE;
+	}
+
+	// Deal with small windows by lowering tolerance
+	if ( ew->w() < 4 * tolerance )
+	{
+		tolerance = 2;
+	}
+
+	int tagnum = GetTagUnderCursorPos( ew, mx, my );
+	if ( tagnum != -1 && CountSelectedEvents() <= 1 )
+	{
+		return DRAGTYPE_EVENTTAG_MOVE;
+	}
+
+	CEventAbsoluteTag *tag = GetAbsoluteTagUnderCursorPos( ew, mx, my );
+	if ( tag != NULL && CountSelectedEvents() <= 1 )
+	{
+		return DRAGTYPE_EVENTABSTAG_MOVE;
+	}
+
+	if ( CountSelectedEvents() > 1 )
+	{
+		CUtlVector< CChoreoEventWidget * > events;
+		GetSelectedEventWidgets( events );
+
+		int iStart, iEnd;
+		iStart = GetEarliestEventIndex( events );
+		iEnd = GetLatestEventIndex( events );
+
+		if ( events.IsValidIndex( iStart ) )
+		{
+			// See if mouse is over left edge of starting event
+			if ( IsMouseOverEventEdge( events[ iStart ], true, mx, my ) )
+			{
+				return DRAGTYPE_RESCALELEFT;
+			}
+		}
+		if ( events.IsValidIndex( iEnd ) )
+		{
+			if ( IsMouseOverEventEdge( events[ iEnd ], false, mx, my ) )
+			{
+				return DRAGTYPE_RESCALERIGHT;
+			}
+		}
+
+		return DRAGTYPE_EVENT_MOVE;
+	}
+
+	CChoreoEvent *event = ew->GetEvent();
+	if ( event )
+	{
+		if ( event->IsFixedLength() || !event->HasEndTime() )
+		{
+			return DRAGTYPE_EVENT_MOVE;
+		}
+	}
+
+	if ( IsMouseOverEventEdge( ew, true, mx, my ) )
+	{
+		if ( GetAsyncKeyState( VK_SHIFT ) )
+			return DRAGTYPE_EVENT_STARTTIME_RESCALE;
+		return DRAGTYPE_EVENT_STARTTIME;
+	}
+
+	if ( IsMouseOverEventEdge( ew, false, mx, my ) )
+	{
+		if ( GetAsyncKeyState( VK_SHIFT ) )
+			return DRAGTYPE_EVENT_ENDTIME_RESCALE;
+		return DRAGTYPE_EVENT_ENDTIME;
+	}
+
+	if ( IsMouseOverEvent( ew, mx, my ) )
+	{
+		return DRAGTYPE_EVENT_MOVE;
+	}
+
+	return DRAGTYPE_NONE;
+}
+
+void CChoreoView::StartDraggingSceneEndTime( int mx, int my )
+{
+	m_nDragType = DRAGTYPE_SCENE_ENDTIME;
+
+	m_FocusRects.Purge();
+
+	RECT rcFocus;
+	rcFocus.left = mx;
+	rcFocus.top = 0;
+	rcFocus.bottom = h2();
+	rcFocus.right = rcFocus.left + 2;
+
+	POINT offset;
+	offset.x = 0;
+	offset.y = 0;
+	ClientToScreen( (HWND)getHandle(), &offset );
+	OffsetRect( &rcFocus, offset.x, offset.y );
+
+	CFocusRect fr;
+	fr.m_rcFocus = rcFocus;
+	fr.m_rcOrig = rcFocus;
+
+	// Relative tag events don't move
+	m_FocusRects.AddToTail( fr );
+
+	m_xStart = mx;
+	m_yStart = my;
+	m_hPrevCursor = SetCursor( LoadCursor( NULL, IDC_SIZEWE ) );
+
+	DrawFocusRect();
+
+	m_bDragging = true;
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+void CChoreoView::StartDraggingEvent( int mx, int my )
+{
+	m_nDragType = ComputeEventDragType( mx, my );
+	if ( m_nDragType == DRAGTYPE_NONE )
+	{
+		if( m_pClickedGlobalEvent )
+		{
+			m_nDragType = DRAGTYPE_EVENT_MOVE;
+		}
+		else
+		{
+			return;
+		}
+	}
+
+	m_FocusRects.Purge();
+
+	// Go through all selected events
+	RECT rcFocus;
+	for ( int i = 0; i < m_SceneActors.Size(); i++ )
+	{
+		CChoreoActorWidget *actor = m_SceneActors[ i ];
+		if ( !actor )
+			continue;
+
+		for ( int j = 0; j < actor->GetNumChannels(); j++ )
+		{
+			CChoreoChannelWidget *channel = actor->GetChannel( j );
+			if ( !channel )
+				continue;
+
+			for ( int k = 0; k < channel->GetNumEvents(); k++ )
+			{
+				CChoreoEventWidget *event = channel->GetEvent( k );
+				if ( !event )
+					continue;
+
+				if ( !event->IsSelected() )
+					continue;
+
+				if ( event == m_pClickedEvent && 
+					( m_nClickedTag != -1 || m_pClickedAbsoluteTag ) )
+				{
+					int leftEdge = 0;
+					int tagWidth = 1;
+					if ( !m_pClickedAbsoluteTag )
+					{
+						CEventRelativeTag *tag = event->GetEvent()->GetRelativeTag( m_nClickedTag );
+						if ( tag )
+						{
+							// Determine left edcge
+							RECT bounds;
+							bounds = event->getBounds();
+							if ( bounds.right - bounds.left > 0 )
+							{
+								leftEdge = (int)( tag->GetPercentage() * (float)( bounds.right - bounds.left ) + 0.5f );
+							}
+						}
+					}
+					else
+					{
+						// Determine left edcge
+						RECT bounds;
+						bounds = event->getBounds();
+						if ( bounds.right - bounds.left > 0 )
+						{
+							leftEdge = (int)( m_pClickedAbsoluteTag->GetPercentage() * (float)( bounds.right - bounds.left ) + 0.5f );
+						}
+					}
+
+					rcFocus.left = event->x() + leftEdge - tagWidth;
+					rcFocus.top = event->y() - tagWidth;
+					rcFocus.right = rcFocus.left + 2 * tagWidth;
+					rcFocus.bottom = event->y() + event->h();
+				}
+				else
+				{
+					rcFocus.left = event->x();
+					rcFocus.top = event->y();
+					if ( event->GetDurationRightEdge() )
+					{
+						rcFocus.right = event->x() + event->GetDurationRightEdge();
+					}
+					else
+					{
+						rcFocus.right = rcFocus.left + event->w();
+					}
+					rcFocus.bottom = rcFocus.top + event->h();
+				}
+
+				POINT offset;
+				offset.x = 0;
+				offset.y = 0;
+				ClientToScreen( (HWND)getHandle(), &offset );
+				OffsetRect( &rcFocus, offset.x, offset.y );
+
+				CFocusRect fr;
+				fr.m_rcFocus = rcFocus;
+				fr.m_rcOrig = rcFocus;
+
+				// Relative tag events don't move
+				m_FocusRects.AddToTail( fr );
+			}
+		}
+	}
+
+	for ( int i = 0; i < m_SceneGlobalEvents.Count(); i++ )
+	{
+		CChoreoGlobalEventWidget *gew = m_SceneGlobalEvents[ i ];
+		if ( !gew )
+			continue;
+
+		if ( !gew->IsSelected() )
+			continue;
+	
+		rcFocus.left = gew->x() + gew->w() / 2;
+		rcFocus.top = 0;
+		rcFocus.right = rcFocus.left + 2;
+		rcFocus.bottom = h2();
+
+		POINT offset;
+		offset.x = 0;
+		offset.y = 0;
+		ClientToScreen( (HWND)getHandle(), &offset );
+		OffsetRect( &rcFocus, offset.x, offset.y );
+
+		CFocusRect fr;
+		fr.m_rcFocus = rcFocus;
+		fr.m_rcOrig = rcFocus;
+
+		m_FocusRects.AddToTail( fr );
+	}
+
+	m_xStart = mx;
+	m_yStart = my;
+	m_hPrevCursor = NULL;
+	switch ( m_nDragType )
+	{
+	default:
+		break;
+	case DRAGTYPE_EVENTTAG_MOVE:
+		m_hPrevCursor = SetCursor( LoadCursor( NULL, IDC_SIZEWE ) );
+		break;
+	case DRAGTYPE_EVENTABSTAG_MOVE:
+		m_hPrevCursor = SetCursor( LoadCursor( NULL, IDC_IBEAM ) );
+		break;
+	case DRAGTYPE_EVENT_MOVE:
+		m_hPrevCursor = SetCursor( LoadCursor( NULL, IDC_SIZEALL ) );
+		break;
+	case DRAGTYPE_EVENT_STARTTIME:
+	case DRAGTYPE_EVENT_STARTTIME_RESCALE:
+		m_hPrevCursor = SetCursor( LoadCursor( NULL, IDC_SIZEWE ) );
+		break;
+	case DRAGTYPE_EVENT_ENDTIME:
+	case DRAGTYPE_EVENT_ENDTIME_RESCALE:
+		m_hPrevCursor = SetCursor( LoadCursor( NULL, IDC_SIZEWE ) );
+		break;
+	case DRAGTYPE_RESCALELEFT:
+	case DRAGTYPE_RESCALERIGHT:
+		m_hPrevCursor = SetCursor( LoadCursor( NULL, IDC_SIZEWE ) );
+		break;
+	}
+
+	DrawFocusRect();
+
+	m_bDragging = true;
+}
+
+bool CChoreoView::IsMouseOverSceneEndTime( int mx )
+{
+	// See if mouse if over scene end time instead
+	if ( m_pScene )
+	{
+		float endtime = m_pScene->FindStopTime();
+
+		bool clip = false;
+		int lastpixel = GetPixelForTimeValue( endtime, &clip );
+		if ( !clip )
+		{
+			if ( abs( mx - lastpixel ) < DRAG_EVENT_EDGE_TOLERANCE )
+			{
+				return true;
+			}
+		}
+	}
+
+	return false;
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+// Input  : mx - 
+//			my - 
+//-----------------------------------------------------------------------------
+void CChoreoView::MouseStartDrag( mxEvent *event, int mx, int my )
+{
+	bool isrightbutton = event->buttons & mxEvent::MouseRightButton ? true : false;
+
+	if ( m_bDragging )
+	{
+		return;
+	}
+
+	GetObjectsUnderMouse( mx, my, &m_pClickedActor, &m_pClickedChannel, &m_pClickedEvent, &m_pClickedGlobalEvent, &m_nClickedTag, &m_pClickedAbsoluteTag, &m_nClickedChannelCloseCaptionButton );
+
+	if ( m_pClickedEvent )
+	{
+		CChoreoEvent *e = m_pClickedEvent->GetEvent();
+		Assert( e );
+
+		int dtPreview = ComputeEventDragType( mx, my );
+		// Shift clicking on exact edge shouldn't toggle selection state
+		bool bIsEdgeRescale = ( dtPreview == DRAGTYPE_EVENT_ENDTIME_RESCALE || dtPreview == DRAGTYPE_EVENT_STARTTIME_RESCALE );
+
+		if ( !( event->modifiers & ( mxEvent::KeyCtrl | mxEvent::KeyShift ) ) )
+		{
+			if ( !m_pClickedEvent->IsSelected() )
+			{
+				DeselectAll();
+			}
+			TraverseWidgets( &CChoreoView::Select, m_pClickedEvent );
+		}
+		else if ( !bIsEdgeRescale )
+		{
+			m_pClickedEvent->SetSelected( !m_pClickedEvent->IsSelected() );
+		}
+
+		switch ( m_pClickedEvent->GetEvent()->GetType() )
+		{
+		default:
+			break;
+		case CChoreoEvent::FLEXANIMATION:
+			{
+				g_pExpressionTool->SetEvent( e );
+				g_pFlexPanel->SetEvent( e );
+			}
+			break;
+		case CChoreoEvent::GESTURE:
+			{
+				g_pGestureTool->SetEvent( e );
+			}
+			break;
+		case CChoreoEvent::SPEAK:
+			{
+				g_pWaveBrowser->SetEvent( e );
+			}
+			break;
+		}
+
+		if ( e->HasEndTime() )
+		{
+			g_pRampTool->SetEvent( e );
+		}
+
+		redraw();
+		StartDraggingEvent( mx, my );
+	}
+	else if ( m_pClickedGlobalEvent )
+	{
+		if ( !( event->modifiers & ( mxEvent::KeyCtrl | mxEvent::KeyShift ) ) )
+		{
+			if ( !m_pClickedGlobalEvent->IsSelected() )
+			{
+				DeselectAll();
+			}
+			TraverseWidgets( &CChoreoView::Select, m_pClickedGlobalEvent );
+		}
+		else
+		{
+			m_pClickedGlobalEvent->SetSelected( !m_pClickedGlobalEvent->IsSelected() );
+		}
+
+		redraw();
+		StartDraggingEvent( mx, my );
+	}
+	else if ( IsMouseOverScrubArea( event ) )
+	{
+		if ( IsMouseOverScrubHandle( event ) )
+		{
+			m_nDragType = DRAGTYPE_SCRUBBER;
+
+			m_bDragging = true;
+			
+			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;
+
+			ClampTimeToSelectionInterval( t );
+
+			SetScrubTime( t );
+			SetScrubTargetTime( t );
+
+			redraw();
+
+			RECT rcScrub;
+			GetScrubHandleRect( rcScrub, true );
+
+			m_FocusRects.Purge();
+
+			// Go through all selected events
+			RECT rcFocus;
+
+			rcFocus.top = GetStartRow();
+			rcFocus.bottom = h2() - m_nScrollbarHeight - m_nInfoHeight;
+			rcFocus.left = ( rcScrub.left + rcScrub.right ) / 2;
+			rcFocus.right = rcFocus.left;
+
+			POINT pt;
+			pt.x = pt.y = 0;
+			ClientToScreen( (HWND)getHandle(), &pt );
+
+			OffsetRect( &rcFocus, pt.x, pt.y );
+
+			CFocusRect fr;
+			fr.m_rcFocus = rcFocus;
+			fr.m_rcOrig = rcFocus;
+
+			m_FocusRects.AddToTail( fr );
+
+			m_xStart = mx;
+			m_yStart = my;
+
+			m_hPrevCursor = SetCursor( LoadCursor( NULL, IDC_SIZEWE ) );
+
+			DrawFocusRect();
+		}
+		else
+		{
+			float t = GetTimeValueForMouse( mx );
+
+			ClampTimeToSelectionInterval( t );
+
+			SetScrubTargetTime( t );
+
+			// Unpause the scene
+			m_bPaused = false;
+			redraw();
+		}
+	}
+	else if ( IsMouseOverSceneEndTime( mx ) )
+	{
+		redraw();
+		StartDraggingSceneEndTime( mx, my );
+	}
+	else  if ( m_pClickedChannel && 
+		m_nClickedChannelCloseCaptionButton != CChoreoChannelWidget::CLOSECAPTION_NONE &&
+		m_nClickedChannelCloseCaptionButton != CChoreoChannelWidget::CLOSECAPTION_CAPTION )
+	{
+		switch ( m_nClickedChannelCloseCaptionButton )
+		{
+		default:
+		case CChoreoChannelWidget::CLOSECAPTION_EXPANDCOLLAPSE:
+			{
+				OnToggleCloseCaptionTags();
+			}
+			break;
+		case CChoreoChannelWidget::CLOSECAPTION_PREVLANGUAGE:
+			{
+				// Change language
+				int id = GetCloseCaptionLanguageId();
+				--id;
+				if ( id < 0 )
+				{
+					id = CC_NUM_LANGUAGES  - 1;
+					Assert( id >= 0 );
+				}
+				SetCloseCaptionLanguageId( id );
+				redraw();
+			}
+			break;
+		case CChoreoChannelWidget::CLOSECAPTION_NEXTLANGUAGE:
+			{
+				int id = GetCloseCaptionLanguageId();
+				++id;
+				if ( id >= CC_NUM_LANGUAGES )
+				{
+					id = 0;
+				}
+				SetCloseCaptionLanguageId( id );
+				redraw();
+			}
+			break;
+		case CChoreoChannelWidget::CLOSECAPTION_SELECTOR:
+			{
+				SetDirty( true );
+
+				PushUndo( "Change selector" );
+
+				m_pClickedChannel->HandleSelectorClicked();
+
+				PushRedo( "Change selector" );
+
+				redraw();
+			}
+			break;
+		}
+	}
+	else
+	{
+		if ( !( event->modifiers & ( mxEvent::KeyCtrl | mxEvent::KeyShift ) ) )
+		{
+			DeselectAll();
+
+			if ( !isrightbutton )
+			{
+				if ( realtime - m_flLastMouseClickTime < 0.3f )
+				{
+					OnDoubleClicked();
+					m_flLastMouseClickTime = -1.0f;
+				}
+				else
+				{
+					m_flLastMouseClickTime = realtime;
+				}
+			}
+
+			redraw();
+		}
+	}
+
+	CalcBounds( m_nDragType );
+}
+
+void CChoreoView::OnDoubleClicked()
+{
+	if ( m_pClickedChannel )
+	{
+		switch (m_nClickedChannelCloseCaptionButton )
+		{
+		default:
+			break;
+		case CChoreoChannelWidget::CLOSECAPTION_NONE:
+			{
+				SetDirty( true );
+				PushUndo( "Enable/disable Channel" );
+		
+				m_pClickedChannel->GetChannel()->SetActive( !m_pClickedChannel->GetChannel()->GetActive() );
+		
+				PushRedo( "Enable/disable Channel" );
+			}
+			break;
+		case CChoreoChannelWidget::CLOSECAPTION_CAPTION:
+			{
+				CChoreoEvent *e = m_pClickedChannel->GetCaptionClickedEvent();
+				if ( e && e->GetNumSlaves() >= 1 )
+				{
+					OnChangeCloseCaptionToken( e );
+				}
+			}
+			break;
+		}
+
+		return;
+	}
+
+	if ( m_pClickedActor )
+	{
+		SetDirty( true );
+		PushUndo( "Enable/disable Actor" );
+
+		m_pClickedActor->GetActor()->SetActive( !m_pClickedActor->GetActor()->GetActive() );
+
+		PushRedo( "Enable/disable Actor" );
+		return;
+	}
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+// Input  : mx - 
+//			my - 
+//-----------------------------------------------------------------------------
+void CChoreoView::MouseContinueDrag( mxEvent *event, int mx, int my )
+{
+	if ( !m_bDragging )
+		return;
+
+	DrawFocusRect();
+
+	ApplyBounds( mx, my );
+
+	for ( int i = 0; i < m_FocusRects.Size(); i++ )
+	{
+		CFocusRect *f = &m_FocusRects[ i ];
+		f->m_rcFocus = f->m_rcOrig;
+
+		switch ( m_nDragType )
+		{
+		default:
+		case DRAGTYPE_SCRUBBER:
+			{
+				float t = GetTimeValueForMouse( mx );
+				t += m_flScrubberTimeOffset;
+
+				ClampTimeToSelectionInterval( t );
+
+				float dt = t - m_flScrub;
+
+				SetScrubTargetTime( t );
+
+				m_bSimulating = true;
+				ScrubThink( dt, true, this );
+
+				SetScrubTime( t );
+
+				OffsetRect( &f->m_rcFocus, ( mx - m_xStart ), 0 );
+			}
+			break;
+		case DRAGTYPE_EVENT_MOVE:
+		case DRAGTYPE_EVENTTAG_MOVE:
+		case DRAGTYPE_EVENTABSTAG_MOVE:
+			{
+				int dx = mx - m_xStart;
+				int dy = my - m_yStart;
+				if ( m_pClickedEvent )
+				{
+					bool shiftdown = ( event->modifiers & mxEvent::KeyShift ) ? true : false;
+					
+
+					// Only allow jumping channels if shift is down
+					if ( !shiftdown )
+					{
+						dy = 0;
+					}
+					if ( abs( dy ) < m_pClickedEvent->GetItemHeight() )
+					{
+						dy = 0;
+					}
+					if ( m_nSelectedEvents > 1 )
+					{
+						dy = 0;
+					}
+					if ( m_nDragType == DRAGTYPE_EVENTTAG_MOVE || m_nDragType == DRAGTYPE_EVENTABSTAG_MOVE )
+					{
+						dy = 0;
+					}
+					
+					if ( m_pClickedEvent->GetEvent()->IsUsingRelativeTag() )
+					{
+						dx = 0;
+					}
+				}
+				else
+				{
+					dy = 0;
+				}
+				OffsetRect( &f->m_rcFocus, dx, dy );
+			}
+			break;
+		case DRAGTYPE_EVENT_STARTTIME:
+		case DRAGTYPE_EVENT_STARTTIME_RESCALE:
+			f->m_rcFocus.left += ( mx - m_xStart );
+			break;
+		case DRAGTYPE_EVENT_ENDTIME:
+		case DRAGTYPE_EVENT_ENDTIME_RESCALE:
+			f->m_rcFocus.right += ( mx - m_xStart );
+			break;
+		case DRAGTYPE_SCENE_ENDTIME:
+			OffsetRect( &f->m_rcFocus, ( mx - m_xStart ), 0 );
+			break;
+		case DRAGTYPE_RESCALELEFT:
+		case DRAGTYPE_RESCALERIGHT:
+			//f->m_rcFocus.right += ( mx - m_xStart );
+			break;
+		}
+	}
+
+	if ( m_nDragType == DRAGTYPE_RESCALELEFT || 
+		 m_nDragType == DRAGTYPE_RESCALERIGHT )
+	{
+		int c = m_FocusRects.Count();
+		int m_nStart = INT_MAX;
+		int m_nEnd = INT_MIN;
+
+		for ( int i = 0; i < c; ++i )
+		{
+			CFocusRect *f = &m_FocusRects[ i ];
+			if ( f->m_rcFocus.left < m_nStart )
+			{
+				m_nStart = f->m_rcFocus.left;
+			}
+			if ( f->m_rcFocus.right > m_nEnd )
+			{
+				m_nEnd = f->m_rcFocus.right;
+			}
+		}
+
+		// Now figure out rescaling logic
+		int dxPixels = mx - m_xStart;
+
+		int oldSize = m_nEnd - m_nStart;
+		if ( oldSize > 0 )
+		{
+			float rescale = 1.0f;
+			if ( m_nDragType == DRAGTYPE_RESCALERIGHT )
+			{
+				rescale = (float)( oldSize + dxPixels )/(float)oldSize;
+			}
+			else
+			{
+				rescale = (float)( oldSize - dxPixels )/(float)oldSize;
+			}
+
+			for ( int i = 0; i < c; ++i )
+			{
+				CFocusRect *f = &m_FocusRects[ i ];
+				int w = f->m_rcFocus.right - f->m_rcFocus.left;
+				if ( m_nDragType == DRAGTYPE_RESCALERIGHT )
+				{
+					f->m_rcFocus.left = m_nStart + ( int )( rescale * (float)( f->m_rcFocus.left - m_nStart ) + 0.5f );
+					f->m_rcFocus.right = f->m_rcFocus.left + ( int )( rescale * (float)w + 0.5f );
+				}
+				else
+				{
+					f->m_rcFocus.right = m_nEnd - ( int )( rescale * (float)( m_nEnd - f->m_rcFocus.right ) + 0.5f );
+					f->m_rcFocus.left = f->m_rcFocus.right - ( int )( rescale * (float)w + 0.5f );
+				}
+			}
+		}
+	}
+	DrawFocusRect();
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+// Input  : mx - 
+//			my - 
+//-----------------------------------------------------------------------------
+void CChoreoView::MouseMove( int mx, int my )
+{
+	if ( m_bDragging )
+		return;
+
+	int dragtype = ComputeEventDragType( mx, my );
+	if ( dragtype == DRAGTYPE_NONE )
+	{
+		CChoreoGlobalEventWidget *ge = NULL;
+		GetObjectsUnderMouse( mx, my, NULL, NULL, NULL, &ge, NULL, NULL, NULL );
+		if ( ge )
+		{
+			dragtype = DRAGTYPE_EVENT_MOVE;
+		}
+
+		if ( dragtype == DRAGTYPE_NONE )
+		{
+			if ( IsMouseOverSceneEndTime( mx ) )
+			{
+				dragtype = DRAGTYPE_SCENE_ENDTIME;
+			}
+		}
+	}
+
+	if ( m_hPrevCursor )
+	{
+		SetCursor( m_hPrevCursor );
+		m_hPrevCursor = NULL;
+	}
+	switch ( dragtype )
+	{
+	default:
+		break;
+	case DRAGTYPE_EVENTTAG_MOVE:
+		m_hPrevCursor = SetCursor( LoadCursor( NULL, IDC_SIZEWE ) );
+		break;
+	case DRAGTYPE_EVENTABSTAG_MOVE:
+		m_hPrevCursor = SetCursor( LoadCursor( NULL, IDC_IBEAM ) );
+		break;
+	case DRAGTYPE_EVENT_MOVE:
+		m_hPrevCursor = SetCursor( LoadCursor( NULL, IDC_SIZEALL ) );
+		break;
+	case DRAGTYPE_EVENT_STARTTIME:
+	case DRAGTYPE_EVENT_STARTTIME_RESCALE:
+	case DRAGTYPE_EVENT_ENDTIME:
+	case DRAGTYPE_EVENT_ENDTIME_RESCALE:
+	case DRAGTYPE_SCENE_ENDTIME:
+	case DRAGTYPE_RESCALELEFT:
+	case DRAGTYPE_RESCALERIGHT:
+		m_hPrevCursor = SetCursor( LoadCursor( NULL, IDC_SIZEWE ) );
+		break;
+	}
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+// Input  : *e - 
+// Output : Returns true on success, false on failure.
+//-----------------------------------------------------------------------------
+bool CChoreoView::CheckGestureLength( CChoreoEvent *e, bool bCheckOnly )
+{
+	Assert( e );
+	if ( !e )
+		return false;
+
+	if ( e->GetType() != CChoreoEvent::GESTURE )
+	{
+		Con_Printf( "CheckGestureLength:  called on non-GESTURE event %s\n", e->GetName() );
+		return false;
+	}
+
+	StudioModel *model = FindAssociatedModel( e->GetScene(), e->GetActor()  );
+	if ( !model )
+		return false;
+
+	CStudioHdr *pStudioHdr = model->GetStudioHdr();
+	if ( !pStudioHdr )
+		return false;
+
+	return UpdateGestureLength( e, pStudioHdr, model->GetPoseParameters(), bCheckOnly );
+}
+
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+// Input  : *e - 
+// Output : Returns true on success, false on failure.
+//-----------------------------------------------------------------------------
+bool CChoreoView::DefaultGestureLength( CChoreoEvent *e, bool bCheckOnly )
+{
+	Assert( e );
+	if ( !e )
+		return false;
+
+	if ( e->GetType() != CChoreoEvent::GESTURE )
+	{
+		Con_Printf( "DefaultGestureLength:  called on non-GESTURE event %s\n", e->GetName() );
+		return false;
+	}
+
+	StudioModel *model = FindAssociatedModel( e->GetScene(), e->GetActor()  );
+	if ( !model )
+		return false;
+
+	if ( !model->GetStudioHdr() )
+		return false;
+
+	int iSequence = model->LookupSequence( e->GetParameters() );
+	if ( iSequence < 0 )
+		return false;
+
+	bool bret = false;
+
+	float seqduration = model->GetDuration( iSequence );
+	if ( seqduration != 0.0f )
+	{
+		bret = true;
+		if ( !bCheckOnly )
+		{
+			e->SetEndTime( e->GetStartTime() + seqduration );
+		}
+	}
+
+	return bret;
+}
+
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+// Input  : *e - 
+// Output : Returns true on success, false on failure.
+//-----------------------------------------------------------------------------
+bool CChoreoView::AutoaddGestureKeys( CChoreoEvent *e, bool bCheckOnly )
+{
+	if ( !e )
+		return false;
+
+	StudioModel *model = FindAssociatedModel( e->GetScene(), e->GetActor() );
+	if ( !model )
+		return false;
+
+	CStudioHdr *pStudioHdr = model->GetStudioHdr();
+	if ( !pStudioHdr )
+		return false;
+
+	return AutoAddGestureKeys( e, pStudioHdr, model->GetPoseParameters(), bCheckOnly );
+}
+
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+bool CChoreoView::CheckSequenceLength( CChoreoEvent *e, bool bCheckOnly )
+{
+	Assert( e );
+	if ( !e )
+		return false;
+
+	if ( e->GetType() != CChoreoEvent::SEQUENCE )
+	{
+		Con_Printf( "CheckSequenceLength:  called on non-SEQUENCE event %s\n", e->GetName() );
+		return false;
+	}
+
+	StudioModel *model = FindAssociatedModel( e->GetScene(), e->GetActor() );
+	if ( !model )
+		return false;
+
+	CStudioHdr *pStudioHdr = model->GetStudioHdr();
+	if ( !pStudioHdr )
+		return false;
+
+	return UpdateSequenceLength( e, pStudioHdr, model->GetPoseParameters(), bCheckOnly, true );
+}
+
+void CChoreoView::FinishDraggingSceneEndTime( mxEvent *event, int mx, int my )
+{
+	DrawFocusRect();
+
+	m_FocusRects.Purge();
+
+	m_bDragging = false;
+
+	float mouse_dt = GetTimeDeltaForMouseDelta( mx, m_xStart );
+	if ( !mouse_dt )
+	{
+		return;
+	}
+
+	SetDirty( true );
+
+	const char *desc = "Change Scene Duration";
+
+	PushUndo( desc );
+
+	float newendtime = GetTimeValueForMouse( mx );
+	float oldendtime = m_pScene->FindStopTime();
+
+	float scene_dt = newendtime - oldendtime;
+
+	for ( int i = 0; i < m_SceneActors.Size(); i++ )
+	{
+		CChoreoActorWidget *a = m_SceneActors[ i ];
+		if ( !a )
+			continue;
+
+		for ( int j = 0; j < a->GetNumChannels(); j++ )
+		{
+			CChoreoChannelWidget *channel = a->GetChannel( j );
+			if ( !channel )
+				continue;
+
+			int k;
+
+			CChoreoEvent *finalGesture = NULL;
+			for ( k = channel->GetNumEvents() - 1; k >= 0; k-- )
+			{
+				CChoreoEventWidget *event = channel->GetEvent( k );
+				CChoreoEvent *e = event->GetEvent();
+				if ( e->GetType() != CChoreoEvent::GESTURE )
+					continue;
+
+				if ( !finalGesture )
+				{
+					finalGesture = e;
+				}
+				else
+				{
+					if ( e->GetStartTime() > finalGesture->GetStartTime() )
+					{
+						finalGesture = e;
+					}
+				}
+			}
+
+
+			for ( k = channel->GetNumEvents() - 1; k >= 0; k-- )
+			{
+				CChoreoEventWidget *event = channel->GetEvent( k );
+				CChoreoEvent *e = event->GetEvent();
+
+				// Event starts after new end time, kill it
+				if ( e->GetStartTime() > newendtime )
+				{
+					channel->GetChannel()->RemoveEvent( e );
+					m_pScene->DeleteReferencedObjects( e );
+					continue;
+				}
+
+				// No change to normal events that end earlier than new time (but do change gestures)
+				if ( e->GetEndTime() < newendtime && 
+					e != finalGesture )
+				{
+					continue;
+				}
+
+				float dt = scene_dt;
+				if ( e->GetType() == CChoreoEvent::GESTURE )
+				{
+					if ( e->GetEndTime() < newendtime )
+					{
+						dt = newendtime - e->GetEndTime();
+					}
+				}
+
+				float newduration = e->GetDuration() + dt;
+				RescaleRamp( e, newduration );
+				switch ( e->GetType() )
+				{
+				default:
+					break;
+				case CChoreoEvent::GESTURE:
+					{
+						e->RescaleGestureTimes( e->GetStartTime(), e->GetEndTime() + dt, true );
+					}
+					break;
+				case CChoreoEvent::FLEXANIMATION:
+					{
+						RescaleExpressionTimes( e, e->GetStartTime(), e->GetEndTime() + dt );
+					}
+					break;
+				}
+				e->OffsetEndTime( dt );
+				e->SnapTimes();
+				e->ResortRamp();
+			}
+		}
+	}
+
+	// Remove event and move to new object
+	DeleteSceneWidgets();
+
+	m_nDragType = DRAGTYPE_NONE;
+
+	if ( m_hPrevCursor )
+	{
+		SetCursor( m_hPrevCursor );
+		m_hPrevCursor = 0;
+	}
+
+	PushRedo( desc );
+
+	CreateSceneWidgets();
+
+	InvalidateLayout();
+
+	g_pExpressionTool->LayoutItems( true );
+	g_pExpressionTool->redraw();
+	g_pGestureTool->redraw();
+	g_pRampTool->redraw();
+	g_pSceneRampTool->redraw();
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: Called after association changes to reset .wav file images
+// Input  :  - 
+//-----------------------------------------------------------------------------
+void CChoreoView::RecomputeWaves()
+{
+	for ( int i = 0; i < m_SceneActors.Size(); i++ )
+	{
+		CChoreoActorWidget *a = m_SceneActors[ i ];
+		if ( !a )
+			continue;
+
+		for ( int j = 0; j < a->GetNumChannels(); j++ )
+		{
+			CChoreoChannelWidget *c = a->GetChannel( j );
+			if ( !c )
+				continue;
+
+			for ( int k = 0; k < c->GetNumEvents(); k++ )
+			{
+				CChoreoEventWidget *e = c->GetEvent( k );
+				if ( !e )
+					continue;
+
+				e->RecomputeWave();
+			}
+		}
+	}
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+// Input  : mx - 
+//			my - 
+//-----------------------------------------------------------------------------
+void CChoreoView::FinishDraggingEvent( mxEvent *event, int mx, int my )
+{
+	DrawFocusRect();
+
+	m_FocusRects.Purge();
+
+	m_bDragging = false;
+
+	float dt = GetTimeDeltaForMouseDelta( mx, m_xStart );
+	if ( !dt )
+	{
+		if ( m_pScene && m_pClickedEvent && m_pClickedEvent->GetEvent()->GetType() == CChoreoEvent::SPEAK )
+		{
+			// Show phone wav in wav viewer
+			char sndname[ 512 ];
+			Q_strncpy( sndname, FacePoser_TranslateSoundName( m_pClickedEvent->GetEvent() ), sizeof( sndname ) );
+			if ( sndname[ 0 ] )
+			{
+				SetCurrentWaveFile( va( "sound/%s", sndname ), m_pClickedEvent->GetEvent() );
+			}
+			else
+			{
+				Warning( "Unable to resolve sound name for '%s', check actor associations\n", m_pClickedEvent->GetEvent()->GetName() );
+			}
+		}
+		return;
+	}
+
+	SetDirty( true );
+
+	char const *desc = "";
+
+	switch ( m_nDragType )
+	{
+		default:
+		case DRAGTYPE_EVENT_MOVE:
+			desc = "Event Move";
+			break;
+		case DRAGTYPE_EVENT_STARTTIME:
+		case DRAGTYPE_EVENT_STARTTIME_RESCALE:
+			desc = "Change Start Time";
+			break;
+		case DRAGTYPE_EVENT_ENDTIME:
+		case DRAGTYPE_EVENT_ENDTIME_RESCALE:
+			desc = "Change End Time";
+			break;
+		case DRAGTYPE_EVENTTAG_MOVE:
+			desc = "Move Event Tag";
+			break;
+		case DRAGTYPE_EVENTABSTAG_MOVE:
+			desc = "Move Abs Event Tag";
+			break;
+		case DRAGTYPE_RESCALELEFT:
+		case DRAGTYPE_RESCALERIGHT:
+			desc = "Rescale Time";
+			break;
+	}
+	PushUndo( desc );
+
+	CUtlVector< CChoreoEvent * > rescaleHelper;
+
+	for ( int i = 0; i < m_SceneActors.Size(); i++ )
+	{
+		CChoreoActorWidget *actor = m_SceneActors[ i ];
+		if ( !actor )
+			continue;
+
+		for ( int j = 0; j < actor->GetNumChannels(); j++ )
+		{
+			CChoreoChannelWidget *channel = actor->GetChannel( j );
+			if ( !channel )
+				continue;
+
+			for ( int k = 0; k < channel->GetNumEvents(); k++ )
+			{
+				CChoreoEventWidget *event = channel->GetEvent( k );
+				if ( !event )
+					continue;
+
+				if ( !event->IsSelected() )
+					continue;
+
+				// Figure out true dt
+				CChoreoEvent *e = event->GetEvent();
+				if ( e )
+				{
+					switch ( m_nDragType )
+					{
+					default:
+					case DRAGTYPE_EVENT_MOVE:
+						e->OffsetTime( dt );
+						e->SnapTimes();
+						break;
+					case DRAGTYPE_EVENT_STARTTIME:
+					case DRAGTYPE_EVENT_STARTTIME_RESCALE:
+						{
+							float newduration = e->GetDuration() - dt;
+							RescaleRamp( e, newduration );
+							switch ( e->GetType() )
+							{
+							default:
+								break;
+							case CChoreoEvent::GESTURE:
+								{
+									e->RescaleGestureTimes( e->GetStartTime() + dt, e->GetEndTime(), m_nDragType == DRAGTYPE_EVENT_STARTTIME );
+								}
+								break;
+							case CChoreoEvent::FLEXANIMATION:
+								{
+									RescaleExpressionTimes( e, e->GetStartTime() + dt, e->GetEndTime() );
+								}
+								break;
+							}
+							e->OffsetStartTime( dt );
+							e->SnapTimes();
+							e->ResortRamp();
+						}
+						break;
+					case DRAGTYPE_EVENT_ENDTIME:
+					case DRAGTYPE_EVENT_ENDTIME_RESCALE:
+						{
+							float newduration = e->GetDuration() + dt;
+							RescaleRamp( e, newduration );
+							switch ( e->GetType() )
+							{
+							default:
+								break;
+							case CChoreoEvent::GESTURE:
+								{
+									e->RescaleGestureTimes( e->GetStartTime(), e->GetEndTime() + dt, m_nDragType == DRAGTYPE_EVENT_ENDTIME );
+								}
+								break;
+							case CChoreoEvent::FLEXANIMATION:
+								{
+									RescaleExpressionTimes( e, e->GetStartTime(), e->GetEndTime() + dt );
+								}
+								break;
+							}
+							e->OffsetEndTime( dt );
+							e->SnapTimes();
+							e->ResortRamp();
+						}
+						break;
+					case DRAGTYPE_RESCALELEFT:
+					case DRAGTYPE_RESCALERIGHT:
+						{
+							rescaleHelper.AddToTail( e );
+						}
+						break;
+					case DRAGTYPE_EVENTTAG_MOVE:
+						{
+							// Get current x position
+							if ( m_nClickedTag != -1 )
+							{
+								CEventRelativeTag *tag = e->GetRelativeTag( m_nClickedTag );
+								if ( tag )
+								{
+									float dx = mx - m_xStart;
+									// Determine left edcge
+									RECT bounds;
+									bounds = event->getBounds();
+									if ( bounds.right - bounds.left > 0 )
+									{
+										int left = bounds.left + (int)( tag->GetPercentage() * (float)( bounds.right - bounds.left ) + 0.5f );
+
+										left += dx;
+
+										if ( left < bounds.left )
+										{
+											left = bounds.left;
+										}
+										else if ( left >= bounds.right )
+										{
+											left = bounds.right - 1;
+										}
+
+										// Now convert back to a percentage
+										float frac = (float)( left - bounds.left ) / (float)( bounds.right - bounds.left );
+
+										tag->SetPercentage( frac );
+									}
+								}
+							}
+						}
+						break;
+					case DRAGTYPE_EVENTABSTAG_MOVE:
+						{
+							// Get current x position
+							if ( m_pClickedAbsoluteTag != NULL )
+							{
+								CEventAbsoluteTag *tag = m_pClickedAbsoluteTag;
+								if ( tag )
+								{
+									float dx = mx - m_xStart;
+									// Determine left edcge
+									RECT bounds;
+									bounds = event->getBounds();
+									if ( bounds.right - bounds.left > 0 )
+									{
+										int left = bounds.left + (int)( tag->GetPercentage() * (float)( bounds.right - bounds.left ) + 0.5f );
+
+										left += dx;
+
+										if ( left < bounds.left )
+										{
+											left = bounds.left;
+										}
+										else if ( left >= bounds.right )
+										{
+											left = bounds.right - 1;
+										}
+
+										// Now convert back to a percentage
+										float frac = (float)( left - bounds.left ) / (float)( bounds.right - bounds.left );
+
+										tag->SetPercentage( frac );
+									}
+								}
+							}
+						}
+						break;
+					}
+				}
+
+				switch ( e->GetType() )
+				{
+				default:
+					break;
+				case CChoreoEvent::SPEAK:
+					{
+						// Try and load wav to get length
+						CAudioSource *wave = sound->LoadSound( va( "sound/%s", FacePoser_TranslateSoundName( e ) ) );
+						if ( wave )
+						{
+							e->SetEndTime( e->GetStartTime() + wave->GetRunningLength() );
+							delete wave;
+						}
+					}
+					break;
+				case CChoreoEvent::SEQUENCE:
+					{
+						CheckSequenceLength( e, false );
+					}
+					break;
+				case CChoreoEvent::GESTURE:
+					{
+						CheckGestureLength( e, false );
+					}
+					break;
+				}
+			}
+		}
+	}
+
+	if ( rescaleHelper.Count() > 0 )
+	{
+		int i;
+		// Determine start and end times for existing "selection"
+		float flStart = FLT_MAX;
+		float flEnd = FLT_MIN;
+		for ( i = 0; i < rescaleHelper.Count(); ++i )
+		{
+			CChoreoEvent *e = rescaleHelper[ i ];
+			float st = e->GetStartTime();
+			float ed = e->GetEndTime();
+
+			if ( st < flStart )
+			{
+				flStart = st;
+			}
+			if ( ed > flEnd )
+			{
+				flEnd = ed;
+			}
+		}
+
+		float flSelectionDuration = flEnd - flStart;
+		if ( flSelectionDuration > 0.0f )
+		{
+			float flNewDuration = 0.0f;
+			if ( m_nDragType == DRAGTYPE_RESCALELEFT )
+			{
+				flNewDuration = max( 0.1f, flSelectionDuration - dt );
+			}
+			else
+			{
+				flNewDuration = max( 0.1f, flSelectionDuration + dt );
+			}
+			float flScale = flNewDuration / flSelectionDuration;
+
+			for ( i = 0; i < rescaleHelper.Count(); ++i )
+			{
+				CChoreoEvent *e = rescaleHelper[ i ];
+				float st = e->GetStartTime();
+				float et = e->HasEndTime() ? e->GetEndTime() : e->GetStartTime();
+				float flTimeFromStart = st - flStart;
+				float flTimeFromEnd = flEnd - et;
+				float flDuration = e->GetDuration();
+			
+				float flNewStartTime = 0.0f;
+				float flNewDuration = 0.0f;
+
+				if ( m_nDragType == DRAGTYPE_RESCALELEFT )
+				{
+					float flNewEndTime = flEnd - flTimeFromEnd * flScale;
+					if ( !e->HasEndTime() || e->IsFixedLength() )
+					{
+						e->OffsetTime( flNewEndTime - flDuration - st );
+						continue;
+					}
+					flNewDuration = flDuration * flScale;
+					flNewStartTime = flNewEndTime - flNewDuration;
+				}
+				else
+				{
+					flNewStartTime = flTimeFromStart * flScale + flStart;
+					if ( !e->HasEndTime() || e->IsFixedLength() )
+					{
+						e->OffsetTime( flNewStartTime - st );
+						continue;
+					}
+					flNewDuration = flDuration * flScale;
+				}
+				
+				RescaleRamp( e, flNewDuration );
+				switch ( e->GetType() )
+				{
+				default:
+					break;
+				case CChoreoEvent::GESTURE:
+					{
+						e->RescaleGestureTimes( flNewStartTime, flNewStartTime + flNewDuration, m_nDragType == DRAGTYPE_EVENT_STARTTIME || m_nDragType == DRAGTYPE_EVENT_ENDTIME );
+					}
+					break;
+				case CChoreoEvent::FLEXANIMATION:
+					{
+						RescaleExpressionTimes( e, flNewStartTime, flNewStartTime + flNewDuration );
+					}
+					break;
+				}
+
+				e->SetStartTime( flNewStartTime );
+				Assert( e->HasEndTime() );
+				e->SetEndTime( flNewStartTime + flNewDuration );
+			}
+		}
+	}
+
+	for ( int i = 0; i < m_SceneGlobalEvents.Count(); i++ )
+	{
+		CChoreoGlobalEventWidget *gew = m_SceneGlobalEvents[ i ];
+		if ( !gew || !gew->IsSelected() )
+			continue;
+
+		CChoreoEvent *e = gew->GetEvent();
+		if ( !e )
+			continue;
+	
+		e->OffsetTime( dt );
+		e->SnapTimes();
+	}
+
+	m_nDragType = DRAGTYPE_NONE;
+
+	if ( m_hPrevCursor )
+	{
+		SetCursor( m_hPrevCursor );
+		m_hPrevCursor = 0;
+	}
+
+	CChoreoEvent *e = m_pClickedEvent ? m_pClickedEvent->GetEvent() : NULL;
+
+	if ( e )
+	{		
+		// See if event is moving to a new owner
+		CChoreoChannelWidget *chOrig, *chNew;
+
+		int dy = my - m_yStart;
+		bool shiftdown = ( event->modifiers & mxEvent::KeyShift ) ? true : false;
+		if ( !shiftdown )
+		{
+			dy = 0;
+		}
+
+		if ( abs( dy ) < m_pClickedEvent->GetItemHeight() )
+		{
+			my = m_yStart;
+		}
+
+		chNew = GetChannelUnderCursorPos( mx, my );
+		
+		InvalidateLayout();
+
+		mx = m_xStart;
+		my = m_yStart;
+
+		chOrig = m_pClickedChannel;
+
+		if ( chOrig && chNew && chOrig != chNew )
+		{
+			// Swap underlying objects
+			CChoreoChannel *pOrigChannel, *pNewChannel;
+
+			pOrigChannel = chOrig->GetChannel();
+			pNewChannel = chNew->GetChannel();
+
+			Assert( pOrigChannel && pNewChannel );
+
+			// Remove event and move to new object
+			DeleteSceneWidgets();
+
+			pOrigChannel->RemoveEvent( e );
+			pNewChannel->AddEvent( e );
+
+			e->SetChannel( pNewChannel );
+			e->SetActor( pNewChannel->GetActor() );
+
+			CreateSceneWidgets();
+		}
+		else
+		{
+			if ( e && e->GetType() == CChoreoEvent::SPEAK )
+			{
+				// Show phone wav in wav viewer
+				SetCurrentWaveFile( va( "sound/%s", FacePoser_TranslateSoundName( e ) ), e );
+			}
+		}
+	}
+
+	PushRedo( desc );
+	InvalidateLayout();
+
+	if ( e )
+	{
+		switch ( e->GetType() )
+		{
+		default:
+			break;
+		case CChoreoEvent::FLEXANIMATION:
+			{
+				g_pExpressionTool->SetEvent( e );
+				g_pFlexPanel->SetEvent( e );
+			}
+			break;
+		case CChoreoEvent::GESTURE:
+			{
+				g_pGestureTool->SetEvent( e );
+			}
+			break;
+		}
+
+		if ( e->HasEndTime() )
+		{
+			g_pRampTool->SetEvent( e );
+		}
+	}
+	g_pExpressionTool->LayoutItems( true );
+	g_pExpressionTool->redraw();
+	g_pGestureTool->redraw();
+	g_pRampTool->redraw();
+	g_pSceneRampTool->redraw();
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+// Input  : mx - 
+//			my - 
+//-----------------------------------------------------------------------------
+void CChoreoView::MouseFinishDrag( mxEvent *event, int mx, int my )
+{
+	if ( !m_bDragging )
+		return;
+
+	ApplyBounds( mx, my );
+
+	switch ( m_nDragType )
+	{
+	case DRAGTYPE_SCRUBBER:
+		{
+			DrawFocusRect();
+	
+			m_FocusRects.Purge();
+
+			float t = GetTimeValueForMouse( mx );
+			t += m_flScrubberTimeOffset;
+			m_flScrubberTimeOffset = 0.0f;
+
+			ClampTimeToSelectionInterval( t );
+
+			SetScrubTime( t );
+			SetScrubTargetTime( t );
+
+			m_bDragging = false;
+			m_nDragType = DRAGTYPE_NONE;
+
+			redraw();
+		}
+		break;
+	case DRAGTYPE_EVENT_MOVE:
+	case DRAGTYPE_EVENT_STARTTIME:
+	case DRAGTYPE_EVENT_STARTTIME_RESCALE:
+	case DRAGTYPE_EVENT_ENDTIME:
+	case DRAGTYPE_EVENT_ENDTIME_RESCALE:
+	case DRAGTYPE_EVENTTAG_MOVE:
+	case DRAGTYPE_EVENTABSTAG_MOVE:
+	case DRAGTYPE_RESCALELEFT:
+	case DRAGTYPE_RESCALERIGHT:
+		FinishDraggingEvent( event, mx, my );
+		break;
+	case DRAGTYPE_SCENE_ENDTIME:
+		FinishDraggingSceneEndTime( event, mx, my );
+		break;
+	default:
+		break;
+	}
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+// Input  : *event - 
+// Output : int
+//-----------------------------------------------------------------------------
+int CChoreoView::handleEvent( mxEvent *event )
+{
+	MDLCACHE_CRITICAL_SECTION_( g_pMDLCache );
+
+	int iret = 0;
+
+	if ( HandleToolEvent( event ) )
+	{
+		return iret;
+	}
+
+	switch ( event->event )
+	{
+	case mxEvent::MouseWheeled:
+		{
+			CChoreoScene *scene = GetScene();
+			if ( scene )
+			{
+				int tz = 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 );
+				}
+
+				SetTimeZoom( GetToolName(), tz, true );
+
+				CUtlVector< CChoreoEvent * > selected;
+				RememberSelectedEvents( selected );
+
+				DeleteSceneWidgets();
+				CreateSceneWidgets();
+
+				ReselectEvents( selected );
+
+				InvalidateLayout();
+				Con_Printf( "Zoom factor %i %%\n", GetTimeZoom( GetToolName() ) );
+			}
+			iret = 1;
+		}
+		break;
+	case mxEvent::Size:
+		{
+			// Force scroll bars to recompute
+			ForceScrollBarsToRecompute( false );
+
+			InvalidateLayout();
+			PositionControls();
+			iret = 1;
+		}
+		break;
+	case mxEvent::MouseDown:
+		{
+			if ( !m_bDragging )
+			{
+				if ( event->buttons & mxEvent::MouseRightButton )
+				{
+					if ( IsMouseOverTimeline( (short)event->x, (short)event->y ) )
+					{
+						PlaceABPoint( (short)event->x );
+						redraw();
+					}
+					else if ( IsMouseOverScrubArea( event ) )
+					{
+						float t = GetTimeValueForMouse( (short)event->x );
+						
+						ClampTimeToSelectionInterval( t );
+
+						SetScrubTime( t );
+						SetScrubTargetTime( t );
+
+						sound->Flush();
+
+						// Unpause the scene
+						m_bPaused = false;
+
+						redraw();
+					}
+					else
+					{
+						// Show right click menu
+						ShowContextMenu( (short)event->x, (short)event->y );
+					}
+				}
+				else
+				{
+					if ( IsMouseOverTimeline( (short)event->x, (short)event->y ) )
+					{
+						ClearABPoints();
+						redraw();
+					}
+					else
+					{
+						// Handle mouse dragging here
+						MouseStartDrag( event, (short)event->x, (short)event->y );
+					}
+				}
+			}
+			iret = 1;
+		}
+		break;
+	case mxEvent::MouseDrag:
+		{
+			MouseContinueDrag( event, (short)event->x, (short)event->y );
+			iret = 1;
+		}
+		break;
+	case mxEvent::MouseUp:
+		{
+			MouseFinishDrag( event, (short)event->x, (short)event->y );
+			iret = 1;
+		}
+		break;
+	case mxEvent::MouseMove:
+		{
+			MouseMove( (short)event->x, (short)event->y );
+			UpdateStatusArea( (short)event->x, (short)event->y );
+			iret = 1;
+		}
+		break;
+	case mxEvent::KeyDown:
+		{
+			iret = 1;
+
+			switch ( event->key )
+			{
+			default:
+				iret = 0;
+				break;
+			case 'E':
+				if ( GetAsyncKeyState( VK_CONTROL ) )
+				{
+					OnPlaceNextSpeakEvent();
+				}
+				break;
+			case VK_ESCAPE:
+				DeselectAll();
+				break;
+			case 'C':
+				CopyEvents();
+				iret = 1;
+				break;
+			case 'V':
+				PasteEvents();
+				redraw();
+				break;
+			case VK_DELETE:
+				{
+					if ( IsActiveTool() )
+					{
+						DeleteSelectedEvents();
+					}
+				}
+				break;
+			case VK_RETURN:
+				{
+					CUtlVector< CChoreoEvent * > events;
+					GetSelectedEvents( events );
+					if ( events.Count() == 1 )
+					{
+						if ( GetAsyncKeyState( VK_MENU ) )
+						{
+							EditEvent( events[ 0 ] );
+							redraw();
+							iret = 1;
+						}
+					}
+				}
+				break;
+			case 'Z':  // Undo/Redo
+				{
+					if ( GetAsyncKeyState( VK_CONTROL ) )
+					{
+						if ( GetAsyncKeyState( VK_SHIFT ) )
+						{
+							if ( CanRedo() )
+							{
+								Con_Printf( "Redo %s\n", GetRedoDescription() );
+								Redo();
+								iret = 1;
+							}
+						}
+						else
+						{
+							if ( CanUndo() )
+							{
+								Con_Printf( "Undo %s\n", GetUndoDescription() );
+								Undo();
+								iret = 1;
+							}
+						}
+					}
+				}
+				break;
+
+			case VK_SPACE:
+				{
+					if ( IsPlayingScene() )
+					{
+						StopScene();
+					}
+				}
+				break;
+			case 188: // VK_OEM_COMMA:
+				{
+					SetScrubTargetTime( 0.0f );
+				}
+				break;
+			case 190: // VK_OEM_PERIOD:
+				{
+					CChoreoScene *scene = GetScene();
+					if ( scene )
+					{
+						SetScrubTargetTime( scene->FindStopTime() );
+					}
+				}
+				break;
+			case VK_LEFT: 
+				{
+					CChoreoScene *scene = GetScene();
+					if ( scene && scene->GetSceneFPS() > 0 )
+					{
+						float curscrub = m_flScrub;
+						curscrub -= ( 1.0f / (float)scene->GetSceneFPS() );
+						curscrub = max( curscrub, 0.0f );
+						SetScrubTargetTime( curscrub );
+					}
+				}
+				break;
+			case VK_RIGHT: 
+				{
+					CChoreoScene *scene = GetScene();
+					if ( scene && scene->GetSceneFPS() > 0 )
+					{
+						float curscrub = m_flScrub;
+						curscrub += ( 1.0f / (float)scene->GetSceneFPS() );
+						curscrub = min( curscrub, scene->FindStopTime() );
+						SetScrubTargetTime( curscrub );
+					}
+				}
+				break;
+			case VK_HOME:
+				{
+					MoveTimeSliderToPos( 0 );
+				}
+				break;
+			case VK_END:
+				{
+					float maxtime = m_pScene->FindStopTime() - 1.0f;
+					int pixels = (int)( maxtime * GetPixelsPerSecond() );
+					MoveTimeSliderToPos( pixels - 1 );
+				}
+				break;
+			case VK_PRIOR:  // PgUp
+				{
+					int window = w2() - GetLabelWidth();
+					m_flLeftOffset = max( m_flLeftOffset - (float)window, 0.0f );
+					MoveTimeSliderToPos( (int)m_flLeftOffset );
+				}
+				break;
+			case VK_NEXT:   // PgDown
+				{
+					int window = w2() - GetLabelWidth();
+					int pixels = ComputeHPixelsNeeded();
+					m_flLeftOffset = min( m_flLeftOffset + (float)window, (float)pixels );
+					MoveTimeSliderToPos( (int)m_flLeftOffset );
+				}
+				break;
+			}
+		}
+		break;
+	case mxEvent::Action:
+		{
+			iret = 1;
+			switch ( event->action )
+			{
+			default:
+				{
+					iret = 0;
+					int lang_index = event->action - IDC_CV_CC_LANGUAGESTART;
+					if ( lang_index >= 0 && lang_index < CC_NUM_LANGUAGES )
+					{
+						iret = 1;
+						SetCloseCaptionLanguageId( lang_index );
+					}
+				}
+				break;
+			case IDC_CV_TOGGLECLOSECAPTIONS:
+				{
+					OnToggleCloseCaptionsForEvent();
+				}
+				break;
+			case IDC_CV_CHANGECLOSECAPTIONTOKEN:
+				{
+					if ( m_pClickedChannel )
+					{
+						CChoreoEvent *e = m_pClickedChannel->GetCaptionClickedEvent();
+						if ( e && e->GetNumSlaves() >= 1 )
+						{
+							OnChangeCloseCaptionToken( e );
+						}
+					}
+				}
+				break;
+			case IDC_CV_REMOVESPEAKEVENTFROMGROUP:
+				{
+					OnRemoveSpeakEventFromGroup();
+				}
+				break;
+			case IDC_CV_COMBINESPEAKEVENTS:
+				{
+					OnCombineSpeakEvents();
+				}
+				break;
+			case IDC_CV_CC_SHOW:
+				{
+					OnToggleCloseCaptionTags();
+				}
+				break;
+			case IDC_CV_TOGGLERAMPONLY:
+				{
+					m_bRampOnly = !m_bRampOnly;
+					redraw();
+				}
+				break;
+			case IDC_CV_PROCESSSEQUENCES:
+				{
+					m_bProcessSequences = !m_bProcessSequences;
+				}
+				break;
+			case IDC_CV_CHECKSEQLENGTHS:
+				{
+					OnCheckSequenceLengths();
+				}
+				break;
+			case IDC_CV_CHANGESCALE:
+				{
+					OnChangeScale();
+				}
+				break;
+			case IDC_CHOREO_PLAYBACKRATE:
+				{
+					m_flPlaybackRate = m_pPlaybackRate->getValue();
+					redraw();
+				}
+				break;
+			case IDC_COPYEVENTS:
+				CopyEvents();
+				break;
+			case IDC_PASTEEVENTS:
+				PasteEvents();
+				redraw();
+				break;
+			case IDC_IMPORTEVENTS:
+				ImportEvents();
+				redraw();
+				break;
+			case IDC_EXPORTEVENTS:
+				ExportEvents();
+				redraw();
+				break;
+			case IDC_EXPORT_VCD:
+				ExportVCD();
+				redraw();
+				break;
+			case IDC_IMPORT_VCD:
+				ImportVCD();
+				redraw();
+				break;
+			case IDC_EXPRESSIONTOOL:
+				OnExpressionTool();
+				break;
+			case IDC_GESTURETOOL:
+				OnGestureTool();
+				break;
+			case IDC_ASSOCIATEBSP:
+				AssociateBSP();
+				break;
+			case IDC_ASSOCIATEMODEL:
+				AssociateModel();
+				break;
+			case IDC_CVUNDO:
+				Undo();
+				break;
+			case IDC_CVREDO:
+				Redo();
+				break;
+			case IDC_SELECTALL:
+				SelectAll();
+				break;
+			case IDC_DESELECTALL:
+				DeselectAll();
+				break;
+			case IDC_PLAYSCENE:	
+				Con_Printf( "Commencing playback\n" );
+				PlayScene( true );
+				break;
+			case IDC_PAUSESCENE:
+				Con_Printf( "Pausing playback\n" );
+				PauseScene();
+				break;
+			case IDC_STOPSCENE:
+				Con_Printf( "Canceling playback\n" );
+				StopScene();
+				break;
+			case IDC_CHOREOVSCROLL:
+				{
+					int offset = 0;
+					bool processed = true;
+
+					switch ( event->modifiers )
+					{
+					case SB_THUMBTRACK:
+						offset = event->height;
+						break;
+					case SB_PAGEUP:
+						offset = m_pVertScrollBar->getValue();
+						offset -= 20;
+						offset = max( offset, m_pVertScrollBar->getMinValue() );
+						break;
+					case SB_PAGEDOWN:
+						offset = m_pVertScrollBar->getValue();
+						offset += 20;
+						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;
+						InvalidateLayout();
+					}
+				}
+				break;
+			case IDC_CHOREOHSCROLL:
+				{
+					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_ADDACTOR:
+				{
+					NewActor();
+				}
+				break;
+			case IDC_EDITACTOR:
+				{
+					CChoreoActorWidget *actor = m_pClickedActor;
+					if ( actor )
+					{
+						EditActor( actor->GetActor() );
+					}			
+				}
+				break;
+			case IDC_DELETEACTOR:
+				{
+					CChoreoActorWidget *actor = m_pClickedActor;
+					if ( actor )
+					{
+						DeleteActor( actor->GetActor() );
+					}
+				}
+				break;
+			case IDC_MOVEACTORUP:
+				{
+					CChoreoActorWidget *actor = m_pClickedActor;
+					if ( actor )				
+					{
+						MoveActorUp( actor->GetActor()  );
+					}
+				}
+				break;
+			case IDC_MOVEACTORDOWN:
+				{
+					CChoreoActorWidget *actor = m_pClickedActor;
+					if ( actor )				
+					{
+						MoveActorDown( actor->GetActor() );
+					}
+				}
+				break;
+			case IDC_CHANNELOPEN:
+				{
+					CActorBitmapButton *btn = static_cast< CActorBitmapButton * >( event->widget );
+					if ( btn )
+					{
+						CChoreoActorWidget *a = btn->GetActor();
+						if ( a )
+						{
+							a->ShowChannels( true );
+						}
+					}
+				}
+				break;
+			case IDC_CHANNELCLOSE:
+				{
+					CActorBitmapButton *btn = static_cast< CActorBitmapButton * >( event->widget );
+					if ( btn )
+					{
+						CChoreoActorWidget *a = btn->GetActor();
+						if ( a )
+						{
+							a->ShowChannels( false );
+						}
+					}
+				}
+				break;
+			case IDC_ADDEVENT_INTERRUPT:
+				{
+					AddEvent( CChoreoEvent::INTERRUPT );
+				}
+				break;
+			case IDC_ADDEVENT_PERMITRESPONSES:
+				{
+					AddEvent( CChoreoEvent::PERMIT_RESPONSES );
+				}
+				break;
+			case IDC_ADDEVENT_EXPRESSION:
+				{
+					AddEvent( CChoreoEvent::EXPRESSION );
+				}
+				break;
+			case IDC_ADDEVENT_FLEXANIMATION:
+				{
+					AddEvent( CChoreoEvent::FLEXANIMATION );
+				}
+				break;
+			case IDC_ADDEVENT_GESTURE:
+				{
+					AddEvent( CChoreoEvent::GESTURE );
+				}
+				break;
+			case IDC_ADDEVENT_NULLGESTURE:
+				{
+					AddEvent( CChoreoEvent::GESTURE, 1 );
+				}
+				break;
+			case IDC_ADDEVENT_LOOKAT:
+				{
+					AddEvent( CChoreoEvent::LOOKAT );
+				}
+				break;
+			case IDC_ADDEVENT_MOVETO:
+				{
+					AddEvent( CChoreoEvent::MOVETO );
+				}
+				break;
+			case IDC_ADDEVENT_FACE:
+				{
+					AddEvent( CChoreoEvent::FACE );
+				}
+				break;
+			case IDC_ADDEVENT_SPEAK:
+				{
+					AddEvent( CChoreoEvent::SPEAK );
+				}
+				break;
+			case IDC_ADDEVENT_FIRETRIGGER:
+				{
+					AddEvent( CChoreoEvent::FIRETRIGGER );
+				}
+				break;
+			case IDC_ADDEVENT_GENERIC:
+				{
+					AddEvent( CChoreoEvent::GENERIC );
+				}
+				break;
+			case IDC_ADDEVENT_SUBSCENE:
+				{
+					AddEvent( CChoreoEvent::SUBSCENE );
+				}
+				break;
+			case IDC_ADDEVENT_SEQUENCE:
+				{
+					AddEvent( CChoreoEvent::SEQUENCE );
+				}
+				break;
+			case IDC_EDITEVENT:
+				{
+					CChoreoEventWidget *event = m_pClickedEvent;
+					if ( event )
+					{
+						EditEvent( event->GetEvent() );
+						redraw();
+					}
+				}
+				break;
+			case IDC_DELETEEVENT:
+				{
+					DeleteSelectedEvents();
+				}
+				break;
+			case IDC_CV_ENABLEEVENTS:
+				{
+					EnableSelectedEvents( true );
+				}
+				break;
+			case IDC_CV_DISABLEEVENTS:
+				{
+					EnableSelectedEvents( false );
+				}
+				break;
+			case IDC_MOVETOBACK:
+				{
+					CChoreoEventWidget *event = m_pClickedEvent;
+					if ( event )
+					{
+						MoveEventToBack( event->GetEvent() );
+					}
+				}
+				break;
+			case IDC_DELETERELATIVETAG:
+				{
+					CChoreoEventWidget *event = m_pClickedEvent;
+					if ( event && m_nClickedTag >= 0 )
+					{
+						DeleteEventRelativeTag( event->GetEvent(), m_nClickedTag );
+					}
+				}
+				break;
+			case IDC_ADDTIMINGTAG:
+				{
+					AddEventRelativeTag();
+				}
+				break;
+			case IDC_ADDEVENT_PAUSE:
+				{
+					AddGlobalEvent( CChoreoEvent::SECTION );
+				}
+				break;
+			case IDC_ADDEVENT_LOOP:
+				{
+					AddGlobalEvent( CChoreoEvent::LOOP );
+				}
+				break;
+			case IDC_ADDEVENT_STOPPOINT:
+				{
+					AddGlobalEvent( CChoreoEvent::STOPPOINT );
+				}
+				break;
+			case IDC_EDITGLOBALEVENT:
+				{
+					CChoreoGlobalEventWidget *event = m_pClickedGlobalEvent;
+					if ( event )
+					{
+						EditGlobalEvent( event->GetEvent() );
+						redraw();
+					}
+				}
+				break;
+			case IDC_DELETEGLOBALEVENT:
+				{
+					CChoreoGlobalEventWidget *event = m_pClickedGlobalEvent;
+					if ( event )
+					{
+						DeleteGlobalEvent( event->GetEvent() );
+					}
+				}
+				break;
+			case IDC_ADDCHANNEL:
+				{
+					NewChannel();
+				}
+				break;
+			case IDC_EDITCHANNEL:
+				{
+					CChoreoChannelWidget *channel = m_pClickedChannel;
+					if ( channel )
+					{
+						EditChannel( channel->GetChannel() );
+					}
+				}
+				break;
+			case IDC_DELETECHANNEL:
+				{
+					CChoreoChannelWidget *channel = m_pClickedChannel;
+					if ( channel )
+					{
+						DeleteChannel( channel->GetChannel() );
+					}
+				}
+				break;
+			case IDC_MOVECHANNELUP:
+				{
+					CChoreoChannelWidget *channel = m_pClickedChannel;
+					if ( channel )
+					{
+						MoveChannelUp( channel->GetChannel() );
+					}
+				}
+				break;
+			case IDC_MOVECHANNELDOWN:
+				{
+					CChoreoChannelWidget *channel = m_pClickedChannel;
+					if ( channel )
+					{
+						MoveChannelDown( channel->GetChannel() );
+					}
+				}
+				break;
+			case IDC_CV_ALLEVENTS_CHANNEL:
+				{
+					CChoreoChannelWidget *channel = m_pClickedChannel;
+					if ( channel )
+					{
+						SelectAllEventsInChannel( channel );
+					}
+				}
+				break;
+			case IDC_CV_ALLEVENTS_ACTOR:
+				{
+					CChoreoActorWidget *actor = m_pClickedActor;
+					if ( actor )
+					{
+						SelectAllEventsInActor( actor );
+					}
+				}
+				break;
+			case IDC_SELECTEVENTS_ALL_BEFORE:
+				{
+					SelectionParams_t params;
+					Q_memset( &params, 0, sizeof( params ) );
+					params.forward = false;
+					params.time = GetTimeValueForMouse( m_nClickedX );
+					params.type = SelectionParams_t::SP_ALL;
+
+					SelectEvents( params );
+				}
+				break;
+			case IDC_SELECTEVENTS_ALL_AFTER:
+				{
+					SelectionParams_t params;
+					Q_memset( &params, 0, sizeof( params ) );
+					params.forward = true;
+					params.time = GetTimeValueForMouse( m_nClickedX );
+					params.type = SelectionParams_t::SP_ALL;
+
+					SelectEvents( params );
+				}
+				break;
+			case IDC_SELECTEVENTS_ACTIVE_BEFORE:
+				{
+					SelectionParams_t params;
+					Q_memset( &params, 0, sizeof( params ) );
+					params.forward = false;
+					params.time = GetTimeValueForMouse( m_nClickedX );
+					params.type = SelectionParams_t::SP_ACTIVE;
+
+					SelectEvents( params );
+				}
+				break;
+			case IDC_SELECTEVENTS_ACTIVE_AFTER:
+				{
+					SelectionParams_t params;
+					Q_memset( &params, 0, sizeof( params ) );
+					params.forward = true;
+					params.time = GetTimeValueForMouse( m_nClickedX );
+					params.type = SelectionParams_t::SP_ACTIVE;
+
+					SelectEvents( params );
+				}
+				break;
+			case IDC_SELECTEVENTS_CHANNEL_BEFORE:
+				{
+					SelectionParams_t params;
+					Q_memset( &params, 0, sizeof( params ) );
+					params.forward = false;
+					params.time = GetTimeValueForMouse( m_nClickedX );
+					params.type = SelectionParams_t::SP_CHANNEL;
+
+					SelectEvents( params );
+				}
+				break;
+			case IDC_SELECTEVENTS_CHANNEL_AFTER:
+				{
+					SelectionParams_t params;
+					Q_memset( &params, 0, sizeof( params ) );
+					params.forward = true;
+					params.time = GetTimeValueForMouse( m_nClickedX );
+					params.type = SelectionParams_t::SP_CHANNEL;
+
+					SelectEvents( params );
+				}
+				break;
+			case IDC_INSERT_TIME:
+				{
+					OnInsertTime();
+				}
+				break;
+			case IDC_DELETE_TIME:
+				{
+					OnDeleteTime();
+				}
+				break;
+			case IDC_CV_ALIGN_LEFT:
+				{
+					OnAlign( true );
+				}
+				break;
+			case IDC_CV_ALIGN_RIGHT:
+				{
+					OnAlign( false );
+				}
+				break;
+			case IDC_CV_SAMESIZE_SMALLEST:
+				{
+					OnMakeSameSize( true );
+				}
+				break;
+			case IDC_CV_SAMESIZE_LARGEST:
+				{
+					OnMakeSameSize( false );
+				}
+				break;
+			}
+
+			if ( iret == 1 )
+			{
+				SetActiveTool( this );
+			}
+		}
+		break;
+	}
+	return iret;
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+void CChoreoView::PlayScene( bool forward )
+{
+	m_bForward = forward;
+	if ( !m_pScene )
+		return;
+
+	sound->Flush();
+
+	// Make sure phonemes are loaded
+	FacePoser_EnsurePhonemesLoaded();
+
+	// Unpause
+	if ( m_bSimulating && m_bPaused )
+	{
+		m_bPaused = false;
+		return;
+	}
+
+	m_bSimulating = true;
+	m_bPaused = false;
+
+//	float soundlatency =  max( sound->GetAmountofTimeAhead(), 0.0f );
+//	soundlatency = min( 0.5f, soundlatency );
+
+	float soundlatency = 0.0f;
+
+	float sceneendtime = m_pScene->FindStopTime();
+
+	m_pScene->SetSoundFileStartupLatency( soundlatency );
+
+	if ( m_rgABPoints[ 0 ].active ||
+		 m_rgABPoints[ 1 ].active  )
+	{
+		if ( m_rgABPoints[ 0 ].active &&
+			 m_rgABPoints[ 1 ].active  )
+		{
+			float st = m_rgABPoints[ 0 ].time;
+			float ed = m_rgABPoints[ 1 ].time;
+
+			m_pScene->ResetSimulation( m_bForward, st, ed );
+
+			SetScrubTime( m_bForward ? st : ed );
+			SetScrubTargetTime( m_bForward ? ed : st );
+		}
+		else
+		{
+			float startonly = m_rgABPoints[ 0 ].active ? m_rgABPoints[ 0 ].time : m_rgABPoints[ 1 ].time;
+
+			m_pScene->ResetSimulation( m_bForward, startonly );
+
+			SetScrubTime( m_bForward ? startonly : sceneendtime );
+			SetScrubTargetTime( m_bForward ? sceneendtime : startonly );
+		}
+	}
+	else
+	{
+		// NO start end/loop
+		m_pScene->ResetSimulation( m_bForward );
+
+		SetScrubTime( m_bForward ? 0 : sceneendtime );
+		SetScrubTargetTime( m_bForward ? sceneendtime : 0 );
+	}
+
+	if ( g_viewerSettings.speedScale == 0.0f )
+	{
+		m_flLastSpeedScale = g_viewerSettings.speedScale;
+		m_bResetSpeedScale = true;
+
+		g_viewerSettings.speedScale = 1.0f;
+
+		Con_Printf( "Resetting speed scale to 1.0\n" );
+	}
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+// Input  : x - 
+//-----------------------------------------------------------------------------
+void CChoreoView::MoveTimeSliderToPos( int x )
+{
+	m_flLeftOffset = (float)x;
+	m_pHorzScrollBar->setValue( (int)m_flLeftOffset );
+	InvalidateRect( (HWND)m_pHorzScrollBar->getHandle(), NULL, TRUE );
+	InvalidateLayout();
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+void CChoreoView::PauseScene( void )
+{
+	if ( !m_bSimulating )
+		return;
+
+	m_bPaused = true;
+	sound->StopAll();
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: Apply expression to actor's face
+// Input  : *event - 
+// Output : Returns true on success, false on failure.
+//-----------------------------------------------------------------------------
+void CChoreoView::ProcessExpression( CChoreoScene *scene, CChoreoEvent *event )
+{
+	Assert( event->GetType() == CChoreoEvent::EXPRESSION );
+
+	StudioModel *model = FindAssociatedModel( scene, event->GetActor() );
+	if ( !model )
+		return;
+
+	CStudioHdr *hdr = model->GetStudioHdr();
+	if ( !hdr )
+	{
+		return;
+	}
+
+	CExpClass *p = expressions->FindClass( event->GetParameters(), true );
+	if ( !p )
+	{
+		return;
+	}
+
+	CExpression *exp = p->FindExpression( event->GetParameters2() );
+	if ( !exp )
+	{
+		return;
+	}
+
+	CChoreoActor *a = event->GetActor();
+	if ( !a )
+		return;
+
+	CChoreoActorWidget *actor = NULL;
+
+	int i;
+	for ( i = 0; i < m_SceneActors.Size(); i++ )
+	{
+		actor = m_SceneActors[ i ];
+		if ( !actor )
+			continue;
+
+		if ( actor->GetActor() == a )
+			break;
+	}
+
+	if ( !actor || i >= m_SceneActors.Size() )
+		return;
+
+	float *settings = exp->GetSettings();
+	Assert( settings );
+	float *weights = exp->GetWeights();
+	Assert( weights );
+	float *current = actor->GetSettings();
+	Assert( current );
+
+	float flIntensity = event->GetIntensity( scene->GetTime() );
+
+	// blend in target values for correct actor
+	for ( LocalFlexController_t i = (LocalFlexController_t)0; i < hdr->numflexcontrollers(); i++ )
+	{
+		mstudioflexcontroller_t *pFlex = hdr->pFlexcontroller( i );
+		int j = pFlex->localToGlobal;
+		if ( j < 0 )
+			continue;
+		float s = clamp( weights[j] * flIntensity, 0.0, 1.0 );
+		current[ j ] = current[j] * (1.0f - s) + settings[ j ] * s;
+	}
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+// Input  : *hdr - 
+//			*event - 
+//-----------------------------------------------------------------------------
+void SetupFlexControllerTracks( CStudioHdr *hdr, CChoreoEvent *event )
+{
+	Assert( hdr );
+	Assert( event );
+
+	if ( !hdr )
+		return;
+
+	if ( !event )
+		return;
+
+	// Already done
+	if ( event->GetTrackLookupSet() )
+		return;
+
+	/*
+	// FIXME:  Brian hooked this stuff up for some took work, but at this point the .mdl files don't look like they've been updated to include the remapping data yet...
+	int c = hdr->numflexcontrollerremaps();
+	for ( i = 0; i < c; ++i )
+	{
+		mstudioflexcontrollerremap_t *remap = hdr->pFlexcontrollerRemap( i );
+		Msg( "remap %s\n", remap->pszName() );
+		Msg( "  type %d\n", remap->remaptype );
+		Msg( "  num remaps %d (stereo %s)\n", remap->numremaps, remap->stereo ? "true" : "false" );
+		for ( int j = 0 ; j < remap->numremaps; ++j )
+		{
+			int index = remap->pRemapControlIndex( j );
+			Msg( "  %d:  maps to %d (%s) with %s\n", j, index, hdr->pFlexcontroller( index )->pszName(), remap->pRemapControl( j ) );
+		}
+	}
+	*/
+
+	// Unlink stuff in case it doesn't exist
+	int	nTrackCount = event->GetNumFlexAnimationTracks();
+	for ( int i = 0; i < nTrackCount; ++i )
+	{
+		CFlexAnimationTrack *pTrack = event->GetFlexAnimationTrack( i );
+		pTrack->SetFlexControllerIndex( LocalFlexController_t(-1), -1, 0 );
+		pTrack->SetFlexControllerIndex( LocalFlexController_t(-1), -1, 1 );
+	}
+
+	for ( LocalFlexController_t i = LocalFlexController_t(0); i < hdr->numflexcontrollers(); ++i )
+	{
+		int j = hdr->pFlexcontroller( i )->localToGlobal;
+
+		char const *name = hdr->pFlexcontroller( i )->pszName();
+		if ( !name )
+			continue;
+
+		bool combo = false;
+		// Look up or create all necessary tracks
+		if ( strncmp( "right_", name, 6 ) == 0 )
+		{
+			combo = true;
+			name = &name[6];
+		}
+
+		CFlexAnimationTrack *track = event->FindTrack( name );
+		if ( !track )
+		{
+			track = event->AddTrack( name );
+			Assert( track );
+		}
+
+		track->SetFlexControllerIndex( i, j, 0 );
+		if ( combo )
+		{
+			track->SetFlexControllerIndex( LocalFlexController_t(i + 1), hdr->pFlexcontroller( LocalFlexController_t(i + 1) )->localToGlobal, 1 );
+			track->SetComboType( true );
+		}
+
+		float orig_min = track->GetMin( );
+		float orig_max = track->GetMax( );
+
+		// set range
+		if (hdr->pFlexcontroller( i )->min == 0.0f || hdr->pFlexcontroller( i )->max == 1.0f)
+		{
+			track->SetInverted( false );
+			track->SetMin( hdr->pFlexcontroller( i )->min );
+			track->SetMax( hdr->pFlexcontroller( i )->max );
+		}
+		else
+		{
+			// invert ranges for wide ranged, makes sense considering flexcontroller names...
+			track->SetInverted( true );
+			track->SetMin( hdr->pFlexcontroller( i )->max );
+			track->SetMax( hdr->pFlexcontroller( i )->min );
+		}
+
+		// resample track based on this models dynamic range
+		if (track->GetNumSamples( 0 ) > 0)
+		{
+			float range = track->GetMax( ) - track->GetMin( );
+
+			for (int i = 0; i < track->GetNumSamples( 0 ); i++)
+			{
+				CExpressionSample	*sample = track->GetSample( i, 0 );
+				float rangedValue = orig_min * (1 - sample->value) + orig_max * sample->value;
+				sample->value = clamp( (rangedValue - track->GetMin( )) / range, 0.0, 1.0 );
+			}
+		}
+
+		// skip next flex since we've already assigned it
+		if ( combo )
+		{
+			i++;
+		}
+	}
+
+	event->SetTrackLookupSet( true );
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: Apply flexanimation to actor's face
+// Input  : *event - 
+// Output : Returns true on success, false on failure.
+//-----------------------------------------------------------------------------
+void CChoreoView::ProcessFlexAnimation( CChoreoScene *scene, CChoreoEvent *event )
+{
+	Assert( event->GetType() == CChoreoEvent::FLEXANIMATION );
+
+	StudioModel *model = FindAssociatedModel( scene, event->GetActor()  );
+	if ( !model )
+		return;
+
+	CStudioHdr *hdr = model->GetStudioHdr();
+	if ( !hdr )
+	{
+		return;
+	}
+
+	CChoreoActor *a = event->GetActor();
+
+	CChoreoActorWidget *actor = NULL;
+
+	int i;
+	for ( i = 0; i < m_SceneActors.Size(); i++ )
+	{
+		actor = m_SceneActors[ i ];
+		if ( !actor )
+			continue;
+
+		if ( !stricmp( actor->GetActor()->GetName(), a->GetName() ) )
+			break;
+	}
+
+	if ( !actor || i >= m_SceneActors.Size() )
+		return;
+
+	float *current = actor->GetSettings();
+	Assert( current );
+
+	if ( !event->GetTrackLookupSet() )
+	{
+		SetupFlexControllerTracks( hdr, event );
+	}
+
+	float weight = event->GetIntensity( scene->GetTime() );
+
+	CChoreoEventWidget *eventwidget = FindWidgetForEvent( event );
+	bool bUpdateSliders = (eventwidget && eventwidget->IsSelected() && model == models->GetActiveStudioModel() );
+
+	// Iterate animation tracks
+	for ( i = 0; i < event->GetNumFlexAnimationTracks(); i++ )
+	{
+		CFlexAnimationTrack *track = event->GetFlexAnimationTrack( i );
+		if ( !track )
+			continue;
+
+		// Disabled
+		if ( !track->IsTrackActive() )
+		{
+			if ( bUpdateSliders )
+			{
+				for ( int side = 0; side < 1 + track->IsComboType(); side++ )
+				{
+					int controller = track->GetFlexControllerIndex( side );
+					if ( controller != -1 && !g_pFlexPanel->IsEdited( controller ))
+					{
+						g_pFlexPanel->SetSlider( controller, 0.0 );
+						g_pFlexPanel->SetInfluence( controller, 0.0f );
+					}
+				}
+			}
+			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( scene->GetTime(), side );
+
+					if (bUpdateSliders && !g_pFlexPanel->IsEdited( controller ) )
+					{
+						g_pFlexPanel->SetSlider( controller, flIntensity );
+						g_pFlexPanel->SetInfluence( controller, 1.0f );
+					}
+
+					flIntensity = current[ controller ] * (1 - weight) + flIntensity * weight;
+					current[ controller ] = flIntensity;
+				}
+			}
+		}
+		else
+		{
+			int controller = track->GetFlexControllerIndex( 0 );
+			if ( controller != -1 )
+			{
+				// Get spline intensity for controller
+				float flIntensity = track->GetIntensity( scene->GetTime(), 0 );
+
+				if (bUpdateSliders && !g_pFlexPanel->IsEdited( controller ) )
+				{
+					g_pFlexPanel->SetSlider( controller, flIntensity );
+					g_pFlexPanel->SetInfluence( controller, 1.0f );
+				}
+
+				flIntensity = current[ controller ] * (1 - weight) + flIntensity * weight;
+				current[ controller ] = flIntensity;
+			}
+		}
+	}
+}
+
+
+#include "mapentities.h"
+
+//-----------------------------------------------------------------------------
+// Purpose: Apply lookat target
+// Input  : *event - 
+// Output : Returns true on success, false on failure.
+//-----------------------------------------------------------------------------
+void CChoreoView::ProcessLookat( CChoreoScene *scene, CChoreoEvent *event )
+{
+	Assert( event->GetType() == CChoreoEvent::LOOKAT );
+
+	if ( !event->GetActor() )
+		return;
+
+	CChoreoActor *a = event->GetActor();
+
+	Assert( a );
+
+	StudioModel *model = FindAssociatedModel( scene, a );
+	if ( !model )
+	{
+		return;
+	}
+
+	float flIntensity = event->GetIntensity( scene->GetTime() );
+
+	// clamp in-ramp to 0.3 seconds
+	float flDuration = scene->GetTime() - event->GetStartTime();
+	float flMaxIntensity = flDuration < 0.3f ? SimpleSpline( flDuration / 0.3f ) : 1.0f;
+	flDuration = event->GetEndTime() - scene->GetTime();
+	flMaxIntensity = min( flMaxIntensity, flDuration < 0.3f ? SimpleSpline( flDuration / 0.3f ) : 1.0f );
+	flIntensity = clamp( flIntensity, 0.0f, flMaxIntensity );
+
+	if (!stricmp( event->GetParameters(), a->GetName() ) || !stricmp( event->GetParameters(), "!self" ))
+	{
+		model->AddLookTargetSelf( flIntensity );
+	}
+	else if ( !stricmp( event->GetParameters(), "player" ) || 
+		!stricmp( event->GetParameters(), "!player" ) )
+	{
+		Vector vecTarget = model->m_origin;
+		vecTarget.z = 0;
+
+		model->AddLookTarget( vecTarget, flIntensity );
+	}
+	else
+	{
+		mapentities->CheckUpdateMap( scene->GetMapname() );
+
+		Vector orgActor;
+		Vector orgTarget;
+		QAngle anglesActor;
+		QAngle anglesDummy;
+
+		if ( event->GetPitch() != 0 ||
+			 event->GetYaw() != 0 )
+		{
+			QAngle angles( -(float)event->GetPitch(),
+				(float)event->GetYaw(),
+				0 );
+
+			matrix3x4_t matrix;
+
+			AngleMatrix( model->m_angles, matrix );
+
+			Vector vecForward;
+			AngleVectors( angles, &vecForward );
+
+			Vector eyeTarget;
+			VectorRotate( vecForward, matrix, eyeTarget );
+			VectorScale( eyeTarget, 75, eyeTarget );
+
+			model->AddLookTarget( eyeTarget, flIntensity );
+		}
+		else
+		{
+			if ( mapentities->LookupOrigin( a->GetName(), orgActor, anglesActor ) )
+			{
+				if ( mapentities->LookupOrigin( event->GetParameters(), orgTarget, anglesDummy ) )
+				{
+					Vector delta = orgTarget - orgActor;
+					
+					matrix3x4_t matrix;
+					Vector lookTarget;
+
+					// Rotate around actor's placed forward direction since we look straight down x in faceposer/hlmv
+					AngleMatrix( anglesActor, matrix );
+					VectorIRotate( delta, matrix, lookTarget );
+					
+					model->AddLookTarget( lookTarget, flIntensity );
+					return;
+				}
+			}
+			// hack up something based on the name.
+			{
+				const char *cp = event->GetParameters();
+				float value = 0.0;
+				while (*cp)
+				{
+					value += *cp++;
+				}
+				value = cos( value );
+				value = acos( value );
+				QAngle angles( 0.0, value * 45 / M_PI, 0.0 );
+
+				matrix3x4_t matrix;
+				AngleMatrix( model->m_angles, matrix );
+
+				Vector vecForward;
+				AngleVectors( angles, &vecForward );
+
+				Vector eyeTarget;
+				VectorRotate( vecForward, matrix, eyeTarget );
+				VectorScale( eyeTarget, 75, eyeTarget );
+
+				model->AddLookTarget( eyeTarget, flIntensity );
+			}
+
+		}
+	}
+}
+
+
+
+//-----------------------------------------------------------------------------
+// Purpose: Returns a target for Faceing
+// Input  : *event - 
+// Output : Returns true on success, false on failure.
+//-----------------------------------------------------------------------------
+bool CChoreoView::GetTarget( CChoreoScene *scene, CChoreoEvent *event, Vector &vecTarget, QAngle &vecAngle )
+{
+	if ( !event->GetActor() )
+		return false;
+
+	CChoreoActor *a = event->GetActor();
+
+	Assert( a );
+
+	StudioModel *model = FindAssociatedModel( scene, a );
+	if ( !model )
+	{
+		return false;
+	}
+
+	if (!stricmp( event->GetParameters(), a->GetName() ))
+	{
+		vecTarget = vec3_origin;
+		return true;
+	}
+	else if ( !stricmp( event->GetParameters(), "player" ) || 
+		!stricmp( event->GetParameters(), "!player" ) )
+	{
+		vecTarget = model->m_origin;
+		vecTarget.z = 0;
+		vecAngle = model->m_angles;
+
+		return true;
+	}
+	else
+	{
+		mapentities->CheckUpdateMap( scene->GetMapname() );
+
+		Vector orgActor;
+		Vector orgTarget;
+		QAngle anglesActor;
+		QAngle anglesDummy;
+
+		if ( event->GetPitch() != 0 ||
+			 event->GetYaw() != 0 )
+		{
+			QAngle angles( -(float)event->GetPitch(),
+				(float)event->GetYaw(),
+				0 );
+
+			matrix3x4_t matrix;
+
+			AngleMatrix( model->m_angles, matrix );
+
+			QAngle angles2 = angles;
+			angles2.x *= 0.6f;
+			angles2.y *= 0.8f;
+
+			Vector vecForward, vecForward2;
+			AngleVectors( angles, &vecForward );
+			AngleVectors( angles2, &vecForward2 );
+
+			VectorNormalize( vecForward );
+			VectorNormalize( vecForward2 );
+
+			Vector eyeTarget, headTarget;
+
+			VectorRotate( vecForward, matrix, eyeTarget );
+			VectorRotate( vecForward2, matrix, headTarget );
+
+			VectorScale( eyeTarget, 150, eyeTarget );
+
+			VectorScale( headTarget, 150, vecTarget );
+			return true;
+
+		}
+		else
+		{
+			if ( mapentities->LookupOrigin( a->GetName(), orgActor, anglesActor ) )
+			{
+				if ( mapentities->LookupOrigin( event->GetParameters(), orgTarget, anglesDummy ) )
+				{
+					Vector delta = orgTarget - orgActor;
+					
+					matrix3x4_t matrix;
+					Vector lookTarget;
+
+					// Rotate around actor's placed forward direction since we look straight down x in faceposer/hlmv
+					AngleMatrix( anglesActor, matrix );
+					VectorIRotate( delta, matrix, vecTarget );
+					
+					return true;
+				}
+			}
+		}
+	}
+	return false;
+}
+
+
+//-----------------------------------------------------------------------------
+// Purpose: Apply lookat target
+// Input  : *event - 
+// Output : Returns true on success, false on failure.
+//-----------------------------------------------------------------------------
+void CChoreoView::ProcessFace( CChoreoScene *scene, CChoreoEvent *event )
+{
+	Assert( event->GetType() == CChoreoEvent::FACE );
+
+	if ( !event->GetActor() )
+		return;
+
+	CChoreoActor *a = event->GetActor();
+
+	Assert( a );
+
+	StudioModel *model = FindAssociatedModel( scene, a );
+	if ( !model )
+	{
+		return;
+	}
+
+	Vector vecTarget;
+	QAngle vecAngle;
+
+	if (!GetTarget( scene, event, vecTarget, vecAngle ))
+	{
+		return;
+	}
+
+	/*
+	// FIXME: this is broke
+	float goalYaw = -(vecAngle.y > 180 ? 360 - vecAngle.y : vecAngle.y );
+
+	float intensity = event->GetIntensity( scene->GetTime() );
+
+	float diff = goalYaw * intensity;
+	float dir = 1.0;
+
+	if (diff < 0)
+	{
+		diff = -diff;
+		dir = -1;
+	}
+
+	float spineintensity = 0 * max( 0.0, (intensity - 0.5) / 0.5 );
+	float goalSpineYaw = min( diff * (1.0 - spineintensity), 30 );
+	//float idealYaw = info->m_flInitialYaw + (diff - m_goalBodyYaw * dir - m_goalSpineYaw * dir) * dir;
+	// float idealYaw = UTIL_AngleMod( info->m_flInitialYaw + diff * intensity );
+
+	// FIXME: this is broke
+	// model->SetSpineYaw( goalSpineYaw * dir);
+	// model->SetBodyYaw( goalBodyYaw * dir );
+
+	// Msg("yaw %.1f : %.1f (%.1f)\n", info->m_flInitialYaw, idealYaw, intensity ); 
+	*/
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+// Input  : *scene - 
+//			*event - 
+//-----------------------------------------------------------------------------
+void CChoreoView::ProcessLoop( CChoreoScene *scene, CChoreoEvent *event )
+{
+	Assert( event->GetType() == CChoreoEvent::LOOP );
+
+	// Don't loop when dragging scrubber!
+	if ( IsScrubbing() )
+		return;
+
+	float backtime = (float)atof( event->GetParameters() );
+
+	bool process = true;
+	int counter = event->GetLoopCount();
+	if ( counter != -1 )
+	{
+		int remaining = event->GetNumLoopsRemaining();
+		if ( remaining <= 0 )
+		{
+			process = false;
+		}
+		else
+		{
+			event->SetNumLoopsRemaining( --remaining );
+		}
+	}
+
+	if ( !process )
+		return;
+
+	scene->LoopToTime( backtime );
+	SetScrubTime( backtime ); 
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: Add a gesture layer
+// Input  : *event - 
+// Output : Returns true on success, false on failure.
+//-----------------------------------------------------------------------------
+void CChoreoView::ProcessGesture( CChoreoScene *scene, CChoreoEvent *event )
+{
+	Assert( event->GetType() == CChoreoEvent::GESTURE );
+
+	// NULL event is just a placeholder
+	if ( !Q_stricmp( event->GetName(), "NULL" ) )
+	{
+		return;
+	}
+
+	StudioModel *model = FindAssociatedModel( scene, event->GetActor()  );
+	if ( !model )
+		return;
+
+	if ( !event->GetActor() )
+		return;
+
+	CChoreoActor *a = event->GetActor();
+
+	Assert( a );
+
+	int iSequence = model->LookupSequence( event->GetParameters() );
+	if (iSequence < 0)
+		return;
+
+	// Get spline intensity for controller
+	float eventlocaltime = scene->GetTime() - event->GetStartTime();
+
+	float referencetime = event->GetOriginalPercentageFromPlaybackPercentage( eventlocaltime / event->GetDuration() ) * event->GetDuration();
+
+	float resampledtime = event->GetStartTime() + referencetime;
+
+	float cycle = event->GetCompletion( resampledtime );
+
+	int iLayer = model->GetNewAnimationLayer( a->FindChannelIndex( event->GetChannel() ) );
+
+	model->SetOverlaySequence( iLayer, iSequence, event->GetIntensity( scene->GetTime() ) );
+	model->SetOverlayRate( iLayer, cycle, 0.0 );
+}
+
+
+
+//-----------------------------------------------------------------------------
+// Purpose: Apply a sequence
+// Input  : *event - 
+//-----------------------------------------------------------------------------
+void CChoreoView::ProcessSequence( CChoreoScene *scene, CChoreoEvent *event )
+{
+	Assert( event->GetType() == CChoreoEvent::SEQUENCE );
+
+	if ( !m_bProcessSequences )
+	{
+		return;
+	}
+
+	StudioModel *model = FindAssociatedModel( scene, event->GetActor()  );
+	if ( !model )
+		return;
+
+	if ( !event->GetActor() )
+		return;
+
+	CChoreoActor *a = event->GetActor();
+
+	Assert( a );
+
+	int iSequence = model->LookupSequence( event->GetParameters() );
+	if (iSequence < 0)
+		return;
+
+	float flFrameRate;
+	float flGroundSpeed;
+	model->GetSequenceInfo( iSequence, &flFrameRate, &flGroundSpeed );
+
+	float cycle;
+	bool looping = model->GetSequenceLoops( iSequence );
+	if (looping)
+	{
+		float dt = scene->GetTime() - event->m_flPrevTime;
+		event->m_flPrevTime = scene->GetTime();
+		dt = clamp( dt, 0.0, 0.1 );
+		cycle = event->m_flPrevCycle + flFrameRate * dt;
+		cycle = cycle - (int)cycle;
+		event->m_flPrevCycle = cycle;
+	}
+	else
+	{
+		float dt = scene->GetTime() - event->GetStartTime();
+		cycle = flFrameRate * dt;
+		cycle = cycle - (int)(cycle);
+	}
+
+	// FIXME: shouldn't sequences always be lower priority than gestures?
+	int iLayer = model->GetNewAnimationLayer( a->FindChannelIndex( event->GetChannel() ) );
+	model->SetOverlaySequence( iLayer, iSequence, event->GetIntensity( scene->GetTime() ) );
+	model->SetOverlayRate( iLayer, cycle, 0.0 );
+}
+
+
+//-----------------------------------------------------------------------------
+// Purpose: Apply a walking animation
+// Input  : *event - 
+//-----------------------------------------------------------------------------
+void CChoreoView::ProcessMoveto( CChoreoScene *scene, CChoreoEvent *event )
+{
+	Assert( event->GetType() == CChoreoEvent::MOVETO );
+
+	if ( !m_bProcessSequences )
+	{
+		return;
+	}
+
+	StudioModel *model = FindAssociatedModel( scene, event->GetActor()  );
+	if ( !model )
+		return;
+
+	if ( !event->GetActor() )
+		return;
+
+	int iSequence = GetMovetoSequence( scene, event, model );
+	if (iSequence < 0)
+		return;
+
+	float flFrameRate;
+	float flGroundSpeed;
+	model->GetSequenceInfo( iSequence, &flFrameRate, &flGroundSpeed );
+
+	float dt = scene->GetTime() - event->GetStartTime();
+	float cycle = flFrameRate * dt;
+	cycle = cycle - (int)(cycle);
+
+	float idealAccel = 100;
+
+	// accel to ideal
+	float t1 = flGroundSpeed / idealAccel;
+
+	float intensity = 1.0;
+
+	if (dt < t1)
+	{
+		intensity = dt / t1;
+	}
+	else if (event->GetDuration() - dt < t1)
+	{
+		intensity = (event->GetDuration() - dt) / t1;
+	}
+
+	// movement should always be higher priority than postures, but not gestures....grrr, any way to tell them apart?
+	int iLayer = model->GetNewAnimationLayer( 0 /* a->FindChannelIndex( event->GetChannel() ) */ );
+	model->SetOverlaySequence( iLayer, iSequence, intensity );
+	model->SetOverlayRate( iLayer, cycle, 0.0 );
+}
+
+
+
+int CChoreoView::GetMovetoSequence( CChoreoScene *scene, CChoreoEvent *event, StudioModel *model )
+{
+	// FIXME: needs to pull from event (activity or sequence?)
+	if ( !event->GetParameters2() || !event->GetParameters2()[0] )
+		return model->LookupSequence( "walk_all" );
+
+	// Custom distance styles are appended to param2 with a space as a separator
+	const char *pszAct = Q_strstr( event->GetParameters2(), " " );
+	if ( pszAct )
+	{
+		char szActName[256];
+		Q_strncpy( szActName, event->GetParameters2(), sizeof(szActName) );
+		szActName[ (pszAct-event->GetParameters2()) ] = '\0';
+		pszAct = szActName;
+	}
+	else
+	{
+		pszAct = event->GetParameters2();
+	}
+
+	if ( !Q_strcmp( pszAct, "Walk" ) )
+	{
+		pszAct = "ACT_WALK";
+	}
+	else if ( !Q_strcmp( pszAct, "Run" ) )
+	{
+		pszAct = "ACT_RUN";
+	}
+	else if ( !Q_strcmp( pszAct, "CrouchWalk" ) )
+	{
+		pszAct = "ACT_WALK_CROUCH";
+	}
+
+	int iSequence = model->LookupActivity( pszAct );
+
+	if (iSequence == -1)
+	{
+		return model->LookupSequence( "walk_all" );
+	}
+	return iSequence;
+}
+
+
+//-----------------------------------------------------------------------------
+// Purpose: Process a pause event
+// Input  : *event - 
+//-----------------------------------------------------------------------------
+void CChoreoView::ProcessPause( CChoreoScene *scene, CChoreoEvent *event )
+{
+	Assert( event->GetType() == CChoreoEvent::SECTION );
+
+	// Don't pause if scrubbing
+	bool scrubbing = ( m_nDragType == DRAGTYPE_SCRUBBER ) ? true : false;
+	if ( scrubbing )
+		return;
+
+	PauseScene();
+
+	m_bAutomated		= false;
+	m_nAutomatedAction	= SCENE_ACTION_UNKNOWN;
+	m_flAutomationDelay = 0.0f;
+	m_flAutomationTime = 0.0f;
+
+	// Check for auto resume/cancel
+	ParseFromMemory( (char *)event->GetParameters(), strlen( event->GetParameters() ) );
+	if ( tokenprocessor->TokenAvailable() )
+	{
+		tokenprocessor->GetToken( false );
+		if ( !stricmp( tokenprocessor->CurrentToken(), "automate" ) )
+		{
+			if ( tokenprocessor->TokenAvailable() )
+			{
+				tokenprocessor->GetToken( false );
+				if ( !stricmp( tokenprocessor->CurrentToken(), "Cancel" ) )
+				{
+					m_nAutomatedAction = SCENE_ACTION_CANCEL;
+				}
+				else if ( !stricmp( tokenprocessor->CurrentToken(), "Resume" ) )
+				{
+					m_nAutomatedAction = SCENE_ACTION_RESUME;
+				}
+
+				if ( tokenprocessor->TokenAvailable() && 
+					m_nAutomatedAction != SCENE_ACTION_UNKNOWN )
+				{
+					tokenprocessor->GetToken( false );
+					m_flAutomationDelay = (float)atof( tokenprocessor->CurrentToken() );
+
+					if ( m_flAutomationDelay > 0.0f )
+					{
+						// Success
+						m_bAutomated = true;
+						m_flAutomationTime = 0.0f;
+					}
+				}
+			}
+		}
+	}
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: Main event processor
+// Input  : *event - 
+// Output : Returns true on success, false on failure.
+//-----------------------------------------------------------------------------
+void CChoreoView::ProcessEvent( float currenttime, CChoreoScene *scene, CChoreoEvent *event )
+{
+	if ( !event || !event->GetActive() )
+		return;
+
+	CChoreoActor *actor = event->GetActor();
+	if ( actor && !actor->GetActive() )
+	{
+		return;
+	}
+
+	CChoreoChannel *channel = event->GetChannel();
+	if ( channel && !channel->GetActive() )
+	{
+		return;
+	}
+
+	switch( event->GetType() )
+	{
+	case CChoreoEvent::EXPRESSION:
+		ProcessExpression( scene, event );
+		break;
+	case CChoreoEvent::FLEXANIMATION:
+		ProcessFlexAnimation( scene, event );
+		break;
+	case CChoreoEvent::LOOKAT:
+		ProcessLookat( scene, event );
+		break;
+	case CChoreoEvent::FACE:
+		ProcessFace( scene, event );
+		break;
+	case CChoreoEvent::GESTURE:
+		ProcessGesture( scene, event );
+		break;
+	case CChoreoEvent::SEQUENCE:
+		ProcessSequence( scene, event );
+		break;
+	case CChoreoEvent::SUBSCENE:
+		ProcessSubscene( scene, event );
+		break;
+	case CChoreoEvent::SPEAK:
+		ProcessSpeak( scene, event );
+		break;
+	case CChoreoEvent::MOVETO:
+		ProcessMoveto( scene, event );
+		break;
+	case CChoreoEvent::STOPPOINT:
+		// Nothing
+		break;
+	case CChoreoEvent::INTERRUPT:
+		ProcessInterrupt( scene, event );
+		break;
+	case CChoreoEvent::PERMIT_RESPONSES:
+		ProcessPermitResponses( scene, event );
+		break;
+	default:
+		break;
+	}
+}
+
+
+//-----------------------------------------------------------------------------
+// Purpose: Main event completion checker
+// Input  : *event - 
+// Output : Returns true on success, false on failure.
+//-----------------------------------------------------------------------------
+bool CChoreoView::CheckEvent( float currenttime, CChoreoScene *scene, CChoreoEvent *event )
+{
+	if ( !event || !event->GetActive() )
+		return true;
+
+	CChoreoActor *actor = event->GetActor();
+	if ( actor && !actor->GetActive() )
+	{
+		return true;
+	}
+
+	CChoreoChannel *channel = event->GetChannel();
+	if ( channel && !channel->GetActive() )
+	{
+		return true;
+	}
+
+	switch( event->GetType() )
+	{
+	case CChoreoEvent::EXPRESSION:
+		break;
+	case CChoreoEvent::FLEXANIMATION:
+		break;
+	case CChoreoEvent::LOOKAT:
+		break;
+	case CChoreoEvent::GESTURE:
+		break;
+	case CChoreoEvent::SEQUENCE:
+		break;
+	case CChoreoEvent::SUBSCENE:
+		break;
+	case CChoreoEvent::SPEAK:
+		break;
+	case CChoreoEvent::MOVETO:
+		break;
+	case CChoreoEvent::INTERRUPT:
+		break;
+	case CChoreoEvent::PERMIT_RESPONSES:
+		break;
+	default:
+		break;
+	}
+	return true;
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+void CChoreoView::PauseThink( void )
+{
+	// FIXME:  Game code would check for conditions being met
+
+	if ( !m_bAutomated )
+		return;
+
+	m_flAutomationTime += fabs( m_flFrameTime );
+
+	RECT rcPauseRect;
+	rcPauseRect.left = 0;
+	rcPauseRect.right = w2();
+	rcPauseRect.top = GetCaptionHeight() + SCRUBBER_HEIGHT;
+	rcPauseRect.bottom = rcPauseRect.top + 10;
+
+	CChoreoWidgetDrawHelper drawHelper( this, 
+		rcPauseRect,
+		COLOR_CHOREO_BACKGROUND );
+
+	DrawSceneABTicks( drawHelper );
+
+	if ( m_flAutomationDelay > 0.0f &&
+		m_flAutomationTime < m_flAutomationDelay )
+	{
+		char sz[ 256 ];
+		sprintf( sz, "Pause %.2f/%.2f", m_flAutomationTime, m_flAutomationDelay );
+	
+		int textlen = drawHelper.CalcTextWidth( "Arial", 9, FW_NORMAL, sz );
+
+		RECT rcText;
+		GetScrubHandleRect( rcText, true );
+
+		rcText.left = ( rcText.left + rcText.right ) / 2;
+		rcText.left -= ( textlen * 0.5f );
+		rcText.right = rcText.left + textlen + 1;
+
+		rcText.top = rcPauseRect.top;
+		rcText.bottom = rcPauseRect.bottom;
+
+		drawHelper.DrawColoredText( "Arial", 9, FW_NORMAL, COLOR_CHOREO_PLAYBACKTICKTEXT, rcText, sz );
+
+		return;
+	}
+
+	// Time to act
+	m_bAutomated = false;
+
+	switch ( m_nAutomatedAction )
+	{
+	case SCENE_ACTION_RESUME:
+		m_bPaused = false;
+		sound->StopAll();
+		break;
+	case SCENE_ACTION_CANCEL:
+		FinishSimulation();
+		break;
+	default:
+		break;
+	}
+
+	m_nAutomatedAction = SCENE_ACTION_UNKNOWN;
+	m_flAutomationTime = 0.0f;
+	m_flAutomationDelay = 0.0f;
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: Conclude simulation
+//-----------------------------------------------------------------------------
+void CChoreoView::FinishSimulation( void )
+{
+	if ( !m_bSimulating )
+		return;
+
+//	m_pScene->ResetSimulation();
+
+	m_bSimulating = false;
+	m_bPaused = false;
+
+	sound->StopAll();
+
+	if ( m_bResetSpeedScale )
+	{
+		m_bResetSpeedScale = false;
+		g_viewerSettings.speedScale = m_flLastSpeedScale;
+		m_flLastSpeedScale = 0.0f;
+
+		Con_Printf( "Resetting speed scale to %f\n", m_flLastSpeedScale );
+	}
+
+	models->ClearOverlaysSequences();
+
+	// redraw();
+}
+
+void CChoreoView::SceneThink( float time )
+{
+	if ( !m_pScene )
+		return;
+
+	if ( m_bSimulating )
+	{
+		if ( m_bPaused )
+		{
+			PauseThink();
+		}
+		else
+		{
+			m_pScene->SetSoundFileStartupLatency( 0.0f );
+
+			models->CheckResetFlexes();
+
+			ResetTargetSettings();
+
+			models->ClearOverlaysSequences();
+			
+			// Tell scene to go
+			m_pScene->Think( time );
+
+			// Move flexes toward their targets
+			UpdateCurrentSettings();
+		}
+	}
+	else
+	{
+		FinishSimulation();
+	}
+
+	if ( !ShouldProcessSpeak() )
+	{
+		bool autoprocess = ShouldAutoProcess();
+		bool anyscrub = IsAnyToolScrubbing() ;
+		bool anyprocessing = IsAnyToolProcessing();
+
+		//Con_Printf( "autoprocess %i anyscrub %i anyprocessing %i\n",
+		//	autoprocess ? 1 : 0,
+		//	anyscrub ? 1 : 0,
+		//	anyprocessing ? 1 : 0 );
+
+		if ( !anyscrub &&
+			 !anyprocessing &&
+			 autoprocess &&
+			 !m_bForceProcess )
+		{
+			sound->StopAll();
+
+			// why clear lookat?
+			//models->ClearModelTargets( false );
+		}
+	}
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+void CChoreoView::LayoutScene( void )
+{
+	if ( !m_pScene )
+		return;
+
+	if ( m_bLayoutIsValid )
+		return;
+
+	m_pScene->ReconcileTags();
+
+	RECT rc;
+	GetClientRect( (HWND)getHandle(), &rc );
+
+	RECT rcClient = rc;
+	rcClient.top += GetStartRow();
+	OffsetRect( &rcClient, 0, -m_nTopOffset );
+
+	m_flStartTime = m_flLeftOffset / GetPixelsPerSecond();
+
+	m_flEndTime = m_flStartTime + (float)( rcClient.right - GetLabelWidth() ) / GetPixelsPerSecond();
+
+	m_rcTimeLine = rcClient;
+	m_rcTimeLine.top = GetCaptionHeight() + SCRUBBER_HEIGHT;
+	m_rcTimeLine.bottom = m_rcTimeLine.top + 44;
+
+	int currentRow = rcClient.top + 2;
+	int itemHeight;
+
+	// Draw actors
+	int i;
+	for ( i = 0; i < m_SceneActors.Size(); i++ )
+	{
+		CChoreoActorWidget *a = m_SceneActors[ i ];
+		Assert( a );
+		if ( !a )
+		{
+			continue;
+		}
+
+		// Figure out rectangle
+		itemHeight = a->GetItemHeight();
+
+		RECT rcActor = rcClient;
+		rcActor.top = currentRow;
+		rcActor.bottom = currentRow + itemHeight;
+
+		a->Layout( rcActor );
+
+		currentRow += itemHeight;
+	}
+
+	// Draw section tabs
+	for ( i = 0; i < m_SceneGlobalEvents.Size(); i++ )
+	{
+		CChoreoGlobalEventWidget *e = m_SceneGlobalEvents[ i ];
+		if ( !e )
+			continue;
+
+		RECT rcEvent;
+		rcEvent = m_rcTimeLine;
+
+		float frac = ( e->GetEvent()->GetStartTime() - m_flStartTime ) / ( m_flEndTime - m_flStartTime );
+			
+		rcEvent.left = GetLabelWidth() + rcEvent.left + (int)( frac * ( m_rcTimeLine.right - m_rcTimeLine.left - GetLabelWidth() ) );
+		rcEvent.left -= 4;
+		rcEvent.right = rcEvent.left + 8;
+		rcEvent.bottom += 0;
+		rcEvent.top = rcEvent.bottom - 8;
+
+		if ( rcEvent.left + 10 < GetLabelWidth() )
+		{
+			e->setVisible( false );
+		}
+		else
+		{
+			e->setVisible( true );
+		}
+
+	//	OffsetRect( &rcEvent, GetLabelWidth(), 0 );
+
+		e->Layout( rcEvent );
+	}
+
+	m_bLayoutIsValid = true;
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+void CChoreoView::DeleteSceneWidgets( void )
+{
+	bool oldcandraw = m_bCanDraw;
+
+	m_bCanDraw = false;
+
+	int i;
+	CChoreoWidget *w;
+
+	ClearStatusArea();
+
+	for( i = 0 ; i < m_SceneActors.Size(); i++ )
+	{
+		w = m_SceneActors[ i ];
+		m_ActorExpanded[ i ].expanded = ((CChoreoActorWidget *)w)->GetShowChannels();
+		delete w;
+	}
+
+	m_SceneActors.RemoveAll();
+
+	for( i = 0 ; i < m_SceneGlobalEvents.Size(); i++ )
+	{
+		w = m_SceneGlobalEvents[ i ];
+		delete w;
+	}
+
+	m_SceneGlobalEvents.RemoveAll();
+
+	m_bCanDraw = oldcandraw;
+
+	// Make sure nobody is still pointing at us
+	m_pClickedActor = NULL;
+	m_pClickedChannel = NULL;
+	m_pClickedEvent = NULL;
+	m_pClickedGlobalEvent = NULL;
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+void CChoreoView::InvalidateLayout( void )
+{
+	if ( m_bSuppressLayout )
+		return;
+
+	if ( ComputeHPixelsNeeded() != m_nLastHPixelsNeeded )
+	{
+		RepositionHSlider();
+	}
+
+	if ( ComputeVPixelsNeeded() != m_nLastVPixelsNeeded )
+	{
+		RepositionVSlider();
+	}
+
+	// Recheck gesture start/end times
+	if ( m_pScene )
+	{
+		m_pScene->ReconcileGestureTimes();
+		m_pScene->ReconcileCloseCaption();
+	}
+
+	m_bLayoutIsValid = false;
+	redraw();
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+void CChoreoView::CreateSceneWidgets( void )
+{
+	DeleteSceneWidgets();
+
+	m_bSuppressLayout = true;
+
+	int i;
+	for ( i = 0; i < m_pScene->GetNumActors(); i++ )
+	{
+		CChoreoActor *a = m_pScene->GetActor( i );
+		Assert( a );
+		if ( !a )
+			continue;
+
+		CChoreoActorWidget *actorWidget = new CChoreoActorWidget( NULL );
+		Assert( actorWidget );
+
+		actorWidget->SetActor( a );
+		actorWidget->Create();
+
+		m_SceneActors.AddToTail( actorWidget );
+
+		actorWidget->ShowChannels( m_ActorExpanded[ i ].expanded );
+	}
+
+	// Find global events
+	for ( i = 0; i < m_pScene->GetNumEvents(); i++ )
+	{
+		CChoreoEvent *e = m_pScene->GetEvent( i );
+		if ( !e || e->GetActor() )
+			continue;
+
+		CChoreoGlobalEventWidget *eventWidget = new CChoreoGlobalEventWidget( NULL );
+		Assert( eventWidget );
+
+		eventWidget->SetEvent( e );
+		eventWidget->Create();
+
+		m_SceneGlobalEvents.AddToTail( eventWidget );
+	}
+
+	m_bSuppressLayout = false;
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+// Output : int
+//-----------------------------------------------------------------------------
+int CChoreoView::GetLabelWidth( void )
+{
+	return m_nLabelWidth;
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+// Output : int
+//-----------------------------------------------------------------------------
+int CChoreoView::GetStartRow( void )
+{
+	return m_nStartRow + GetCaptionHeight() + SCRUBBER_HEIGHT;
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+// Output : int
+//-----------------------------------------------------------------------------
+int CChoreoView::GetRowHeight( void )
+{
+	return m_nRowHeight;
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+// Output : int
+//-----------------------------------------------------------------------------
+int CChoreoView::GetFontSize( void )
+{
+	return m_nFontSize;
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+// Output : int
+//-----------------------------------------------------------------------------
+int CChoreoView::ComputeVPixelsNeeded( void )
+{
+	int pixels = 0;
+	for ( int i = 0; i < m_SceneActors.Size(); i++ )
+	{
+		CChoreoActorWidget *actor = m_SceneActors[ i ];
+		if ( !actor )
+			continue;
+
+		pixels += actor->GetItemHeight() + 2;
+	}
+
+	pixels += GetStartRow() + 15;
+
+//	pixels += m_nInfoHeight;
+
+	//pixels += 30;
+	return pixels;
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+// Output : int
+//-----------------------------------------------------------------------------
+int CChoreoView::ComputeHPixelsNeeded( void )
+{
+	if ( !m_pScene )
+	{
+		return 0;
+	}
+
+	int pixels = 0;
+	float maxtime = m_pScene->FindStopTime();
+	if ( maxtime < 5.0 )
+	{
+		maxtime = 5.0f;
+	}
+	pixels = (int)( ( maxtime + 5.0 ) * GetPixelsPerSecond() );
+
+	return pixels;
+
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+void CChoreoView::RepositionVSlider( void )
+{
+	int pixelsneeded = ComputeVPixelsNeeded();
+
+	if ( pixelsneeded <= ( h2() - GetStartRow() ))
+	{
+		m_pVertScrollBar->setVisible( false );
+		m_nTopOffset = 0;
+	}
+	else
+	{
+		m_pVertScrollBar->setVisible( true );
+	}
+
+	m_pVertScrollBar->setBounds( w2() - m_nScrollbarHeight, GetStartRow(), m_nScrollbarHeight, h2() - m_nScrollbarHeight - GetStartRow() );
+
+	//int visiblepixels = h2() - m_nScrollbarHeight - GetStartRow();
+	//m_nTopOffset = min( pixelsneeded - visiblepixels, m_nTopOffset );
+	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() - GetStartRow() );
+
+	m_nLastVPixelsNeeded = pixelsneeded;
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+void CChoreoView::RepositionHSlider( void )
+{
+	int pixelsneeded = ComputeHPixelsNeeded();
+
+	int w = w2();
+	int lw = GetLabelWidth();
+
+	if ( pixelsneeded <= ( w - lw ) )
+	{
+		m_pHorzScrollBar->setVisible( false );
+	}
+	else
+	{
+		m_pHorzScrollBar->setVisible( true );
+	}
+	m_pHorzScrollBar->setBounds( 0, h2() - m_nScrollbarHeight, w - m_nScrollbarHeight, m_nScrollbarHeight );
+
+	m_flLeftOffset = max( 0.f, m_flLeftOffset );
+	m_flLeftOffset = min( (float)pixelsneeded, m_flLeftOffset );
+
+	m_pHorzScrollBar->setRange( 0, pixelsneeded );
+	m_pHorzScrollBar->setValue( (int)m_flLeftOffset );
+	m_pHorzScrollBar->setPagesize(w - lw );
+
+	m_nLastHPixelsNeeded = pixelsneeded;
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+// Input  : dirty - 
+//-----------------------------------------------------------------------------
+void CChoreoView::SetDirty( bool dirty, bool clearundo /*=true*/ )
+{
+	bool changed = dirty != m_bDirty;
+
+	m_bDirty = dirty;
+
+	if ( !dirty && clearundo )
+	{
+		WipeUndo();
+		redraw();
+	}
+
+	if ( changed )
+	{
+		SetPrefix( m_bDirty ? "* " : "" );
+	}
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+void CChoreoView::New( void )
+{
+	if ( m_pScene )
+	{
+		Close( );
+		if ( m_pScene )
+		{
+			return;
+		}
+	}
+
+	char scenefile[ 512 ];
+	if ( FacePoser_ShowSaveFileNameDialog( scenefile, sizeof( scenefile ), "scenes", "*.vcd" ) )
+	{
+		Q_DefaultExtension( scenefile, ".vcd", sizeof( scenefile ) );
+		
+		m_pScene = new CChoreoScene( this );
+		g_MDLViewer->InitGridSettings();
+		SetChoreoFile( scenefile );
+		m_pScene->SetPrintFunc( Con_Printf );
+
+		ShowButtons( true );
+
+		SetDirty( false );
+	}
+
+	if ( !m_pScene )
+		return;
+
+	// Get first actor name
+	CActorParams params;
+	memset( &params, 0, sizeof( params ) );
+
+	strcpy( params.m_szDialogTitle, "Create Actor" );
+	strcpy( params.m_szName, "" );
+
+	if ( !ActorProperties( &params ) )
+		return;
+
+	if ( strlen( params.m_szName ) <= 0 )
+		return;
+
+	SetDirty( true );
+
+	PushUndo( "Create Actor" );
+
+	Con_Printf( "Creating scene %s with actor '%s'\n", GetChoreoFile(), params.m_szName );
+
+	CChoreoActor *actor = m_pScene->AllocActor();
+	if ( actor )
+	{
+		actor->SetName( params.m_szName );
+	}
+
+	PushRedo( "Create Actor" );
+
+	CreateSceneWidgets();
+	// Redraw
+	InvalidateLayout();
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+void CChoreoView::Save( void )
+{
+	if ( !m_pScene )
+		return;
+
+	if ( !MakeFileWriteablePrompt( GetChoreoFile(), "VCD File" ) )
+	{
+		Con_Printf( "Not saving changes to %s\n", GetChoreoFile() );
+		return;
+	}
+
+	Con_Printf( "Saving changes to %s\n", GetChoreoFile() );
+
+	CP4AutoEditAddFile checkout( GetChoreoFile() );
+	if ( !m_pScene->SaveToFile( GetChoreoFile() ) )
+	{
+  		mxMessageBox( this, va( "Unable to write \"%s\"", GetChoreoFile() ),
+  			"SaveToFile", MX_MB_OK | MX_MB_ERROR );
+	}
+
+	g_MDLViewer->OnVCDSaved();
+
+	// Refresh the suffix
+	SetChoreoFile( GetChoreoFile() );
+
+	SetDirty( false, false );
+	redraw();
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+void CChoreoView::SaveAs( void )
+{
+	if ( !m_pScene )
+		return;
+
+	char scenefile[ 512 ];
+	if ( !FacePoser_ShowSaveFileNameDialog( scenefile, sizeof( scenefile ), "scenes", "*.vcd" ) )
+		return;
+
+	Q_DefaultExtension( scenefile, ".vcd", sizeof( scenefile ) );
+	
+	Con_Printf( "Saving %s\n", scenefile );
+
+	MakeFileWriteable( scenefile );
+
+	// Change filename
+	SetChoreoFile( scenefile );
+
+	// Write it out baby
+	CP4AutoEditAddFile checkout( scenefile );
+	if (!m_pScene->SaveToFile( GetChoreoFile() ))
+	{
+  		mxMessageBox( this, va( "Unable to write \"%s\"", GetChoreoFile() ),
+  			"SaveToFile", MX_MB_OK | MX_MB_ERROR );
+	}
+
+	g_MDLViewer->OnVCDSaved();
+
+	SetDirty( false, false );
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+void CChoreoView::Load( void )
+{
+	char scenefile[ 512 ];
+	if ( !FacePoser_ShowOpenFileNameDialog( scenefile, sizeof( scenefile ), "scenes", "*.vcd" ) )
+	{
+		return;
+	}
+
+	Q_DefaultExtension( scenefile, ".vcd", sizeof( scenefile ) );
+
+	LoadSceneFromFile( scenefile );
+
+	m_nextFileList.RemoveAll();
+}
+
+void CChoreoView::LoadNext( void )
+{
+	if (GetChoreoFile() == NULL)
+		return;
+
+	char fixedupFile[ 512 ];
+	V_FixupPathName( fixedupFile, sizeof( fixedupFile ), GetChoreoFile() );
+
+	char relativeFile[ 512 ];
+	filesystem->FullPathToRelativePath( fixedupFile, relativeFile, sizeof( relativeFile ) );
+
+	char relativePath[ 512 ];
+	Q_ExtractFilePath( relativeFile, relativePath, sizeof( relativePath ) );
+
+	if (m_nextFileList.Count() == 0)
+	{
+		// iterate files in the local directory
+		char path[ 512 ];
+		strcpy( path, relativePath );
+		strcat( path, "/*.vcd" );
+
+		FileFindHandle_t hFindFile;
+		char const *fn = filesystem->FindFirstEx( path, "MOD", &hFindFile );
+		if ( fn )
+		{
+			while ( fn )
+			{
+				// Don't do anything with directories
+				if ( !filesystem->FindIsDirectory( hFindFile ) )
+				{
+					CUtlString s = fn;
+					m_nextFileList.AddToTail( s );
+				}
+
+				fn = filesystem->FindNext( hFindFile );
+			}
+
+			filesystem->FindClose( hFindFile );
+		}
+	}
+
+	// look for a match, then pick the next in the list
+	const char *fileBase;
+	fileBase = V_UnqualifiedFileName( fixedupFile );
+
+	for (int i = 0; i < m_nextFileList.Count(); i++)
+	{
+		if (!stricmp( fileBase, m_nextFileList[i] ))
+		{
+			char fileName[512];
+			strcpy( fileName, relativePath );
+			if (i < m_nextFileList.Count() - 1)
+			{
+				strcat( fileName, m_nextFileList[i+1] );
+			}
+			else
+			{
+				strcat( fileName, m_nextFileList[0] );
+			}
+
+			LoadSceneFromFile( fileName );
+			break;
+		}
+	}
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+// Input  : *filename - 
+//-----------------------------------------------------------------------------
+void CChoreoView::LoadSceneFromFile( const char *filename )
+{
+	if ( filename[ 0 ] == '/' ||
+		 filename[ 0 ] == '\\' )
+	{
+		++filename;
+	}
+
+	char fn[ 512 ];
+	Q_strncpy( fn, filename, sizeof( fn ) );
+	if ( m_pScene )
+	{
+		Close();
+		if ( m_pScene )
+		{
+			return;
+		}
+	}
+
+	m_pScene = LoadScene( fn );
+	g_MDLViewer->InitGridSettings();
+	if ( !m_pScene )
+		return;
+
+	g_MDLViewer->OnFileLoaded( fn );
+
+	ShowButtons( true );
+
+	CChoreoWidget::m_pScene = m_pScene;
+	SetChoreoFile( fn );
+
+	bool cleaned = FixupSequenceDurations( m_pScene, false );
+
+	SetDirty( cleaned );
+
+	DeleteSceneWidgets();
+	CreateSceneWidgets();
+
+	// Force scroll bars to recompute
+	ForceScrollBarsToRecompute( false );
+
+	InvalidateLayout();
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+// Input  : closing - 
+//-----------------------------------------------------------------------------
+void CChoreoView::UnloadScene( void )
+{
+	InvalidateLayout();
+	ReportSceneClearToTools();
+
+	ClearStatusArea();
+
+	delete m_pScene;
+	m_pScene = NULL;
+	SetDirty( false );
+	SetChoreoFile( "" );
+	g_MDLViewer->InitGridSettings();
+	CChoreoWidget::m_pScene = NULL;
+
+	DeleteSceneWidgets();
+
+	m_pVertScrollBar->setVisible( false );
+	m_pHorzScrollBar->setVisible( false );
+
+	ShowButtons( false );
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+// Input  : *channel - 
+//-----------------------------------------------------------------------------
+void CChoreoView::DeleteChannel( CChoreoChannel *channel )
+{
+	if ( !channel || !m_pScene )
+		return;
+
+	SetDirty( true );
+
+	PushUndo( "Delete Channel" );
+
+	DeleteSceneWidgets();
+
+	// Delete channel and it's children
+	// Find the appropriate actor
+	for ( int i = 0; i < m_pScene->GetNumActors(); i++ )
+	{
+		CChoreoActor *a = m_pScene->GetActor( i );
+		if ( !a )
+			continue;
+
+		if ( a->FindChannelIndex( channel ) == -1 )
+			continue;
+
+		Con_Printf( "Deleting %s\n", channel->GetName() );
+		a->RemoveChannel( channel );
+			
+		m_pScene->DeleteReferencedObjects( channel );
+		break;
+	}
+
+	ReportSceneClearToTools();
+
+	CreateSceneWidgets();
+
+	PushRedo( "Delete Channel" );
+
+	// Redraw
+	InvalidateLayout();
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+void CChoreoView::NewChannel( void )
+{
+	if ( !m_pScene )
+		return;
+
+	if ( !m_pScene->GetNumActors() )
+	{
+		Con_Printf( "You must create an actor before you can add a channel\n" );
+		return;
+	}
+
+	CChannelParams params;
+	memset( &params, 0, sizeof( params ) );
+
+	strcpy( params.m_szDialogTitle, "Create Channel" );
+	strcpy( params.m_szName, "" );
+	params.m_bShowActors = true;
+	strcpy( params.m_szSelectedActor, "" );
+	params.m_pScene = m_pScene;
+
+	if ( !ChannelProperties( &params ) )
+	{
+		return;
+	}
+
+	if ( strlen( params.m_szName ) <= 0 )
+	{
+		return;
+	}
+
+	CChoreoActor *actor = m_pScene->FindActor( params.m_szSelectedActor );
+	if ( !actor )
+	{
+		Con_Printf( "Can't add channel %s, actor %s doesn't exist\n", params.m_szName, params.m_szSelectedActor );
+		return;
+	}
+
+	SetDirty( true );
+
+	PushUndo( "Add Channel" );
+
+	DeleteSceneWidgets();
+
+	CChoreoChannel *channel = m_pScene->AllocChannel();
+	if ( !channel )
+	{
+		Con_Printf( "Unable to allocate channel %s!\n", params.m_szName );
+	}
+	else
+	{
+		channel->SetName( params.m_szName );
+		channel->SetActor( actor );
+		actor->AddChannel( channel );
+	}
+
+	CreateSceneWidgets();
+
+	PushRedo( "Add Channel" );
+
+	// Redraw
+	InvalidateLayout();
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+// Input  : *channel - 
+//-----------------------------------------------------------------------------
+void CChoreoView::MoveChannelUp( CChoreoChannel *channel )
+{
+	SetDirty( true );
+
+	PushUndo( "Move Channel Up" );
+
+	DeleteSceneWidgets();
+
+	// Find the appropriate actor
+	for ( int i = 0; i < m_pScene->GetNumActors(); i++ )
+	{
+		CChoreoActor *a = m_pScene->GetActor( i );
+		if ( !a )
+			continue;
+
+		int index = a->FindChannelIndex( channel );
+		if ( index == -1 )
+			continue;
+
+		if ( index != 0 )
+		{
+			Con_Printf( "Moving %s up\n", channel->GetName() );
+			a->SwapChannels( index, index - 1 );
+		}
+		break;
+	}
+
+	CreateSceneWidgets();
+
+	PushRedo( "Move Channel Up" );
+
+	// Redraw
+	InvalidateLayout();
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+// Input  : *channel - 
+//-----------------------------------------------------------------------------
+void CChoreoView::MoveChannelDown( CChoreoChannel *channel )
+{
+	SetDirty( true );
+
+	PushUndo( "Move Channel Down" );
+
+	DeleteSceneWidgets();
+
+	// Find the appropriate actor
+	for ( int i = 0; i < m_pScene->GetNumActors(); i++ )
+	{
+		CChoreoActor *a = m_pScene->GetActor( i );
+		if ( !a )
+			continue;
+
+		int index = a->FindChannelIndex( channel );
+		if ( index == -1 )
+			continue;
+
+		if ( index < a->GetNumChannels() - 1 )
+		{
+			Con_Printf( "Moving %s down\n", channel->GetName() );
+			a->SwapChannels( index, index + 1 );
+		}
+		break;
+	}
+
+	CreateSceneWidgets();
+
+	PushRedo( "Move Channel Down" );
+
+	// Redraw
+	InvalidateLayout();
+}
+
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+// Input  : *channel - 
+//-----------------------------------------------------------------------------
+void CChoreoView::EditChannel( CChoreoChannel *channel )
+{
+	if ( !channel )
+		return;
+
+	CChannelParams params;
+	memset( &params, 0, sizeof( params ) );
+
+	strcpy( params.m_szDialogTitle, "Edit Channel" );
+	V_strcpy_safe( params.m_szName, channel->GetName() );
+
+	if ( !ChannelProperties( &params ) )
+		return;
+
+	if ( strlen( params.m_szName ) <= 0 )
+		return;
+
+	SetDirty( true );
+
+	PushUndo( "Edit Channel" );
+
+	channel->SetName( params.m_szName );
+
+	PushRedo( "Edit Channel" );
+
+	// Redraw
+	InvalidateLayout();
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+// Input  : *actor - 
+//-----------------------------------------------------------------------------
+void CChoreoView::DeleteActor( CChoreoActor *actor )
+{
+	if ( !actor || !m_pScene )
+		return;
+
+	SetDirty( true );
+
+	PushUndo( "Delete Actor" );
+
+	DeleteSceneWidgets();
+
+	// Delete channel and it's children
+	// Find the appropriate actor
+	Con_Printf( "Deleting %s\n", actor->GetName() );
+	m_pScene->RemoveActor( actor );
+
+	m_pScene->DeleteReferencedObjects( actor );
+
+	ReportSceneClearToTools();
+
+	CreateSceneWidgets();
+
+	PushRedo( "Delete Actor" );
+
+	// Redraw
+	InvalidateLayout();
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+void CChoreoView::NewActor( void )
+{
+	if ( !m_pScene )
+	{
+		Con_ErrorPrintf( "You must load or create a scene file first\n" );
+		return;
+	}
+
+	CActorParams params;
+	memset( &params, 0, sizeof( params ) );
+
+	strcpy( params.m_szDialogTitle, "Create Actor" );
+	strcpy( params.m_szName, "" );
+
+	if ( !ActorProperties( &params ) )
+		return;
+
+	if ( strlen( params.m_szName ) <= 0 )
+		return;
+
+	SetDirty( true );
+
+	PushUndo( "Add Actor" );
+
+	DeleteSceneWidgets();
+
+	Con_Printf( "Adding new actor '%s'\n", params.m_szName );
+
+	CChoreoActor *actor = m_pScene->AllocActor();
+	if ( actor )
+	{
+		actor->SetName( params.m_szName );
+	}
+
+	CreateSceneWidgets();
+
+	PushRedo( "Add Actor" );
+
+	// Redraw
+	InvalidateLayout();
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+// Input  : *actor - 
+//-----------------------------------------------------------------------------
+void CChoreoView::MoveActorUp( CChoreoActor *actor )
+{
+	DeleteSceneWidgets();
+
+	int index = m_pScene->FindActorIndex( actor );
+	// found it and it's not first
+	if ( index != -1 && index != 0 )
+	{
+		Con_Printf( "Moving %s up\n", actor->GetName() );
+
+		SetDirty( true );
+
+		PushUndo( "Move Actor Up" );
+
+		m_pScene->SwapActors( index, index - 1 );
+
+		PushRedo( "Move Actor Up" );
+	}
+
+	CreateSceneWidgets();
+	// Redraw
+	InvalidateLayout();
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+// Input  : *actor - 
+//-----------------------------------------------------------------------------
+void CChoreoView::MoveActorDown( CChoreoActor *actor )
+{
+	DeleteSceneWidgets();
+
+	int index = m_pScene->FindActorIndex( actor );
+	// found it and it's not first
+	if ( index != -1 && ( index < m_pScene->GetNumActors() - 1 ) )
+	{
+		Con_Printf( "Moving %s down\n", actor->GetName() );
+		
+		SetDirty( true );
+	
+		PushUndo( "Move Actor Down" );
+
+		m_pScene->SwapActors( index, index + 1 );
+
+		PushRedo( "Move Actor Down" );
+	}
+
+	CreateSceneWidgets();
+	// Redraw
+	InvalidateLayout();
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+// Input  : *actor - 
+//-----------------------------------------------------------------------------
+void CChoreoView::EditActor( CChoreoActor *actor )
+{
+	if ( !actor )
+		return;
+
+	CActorParams params;
+	memset( &params, 0, sizeof( params ) );
+
+	strcpy( params.m_szDialogTitle, "Edit Actor" );
+	V_strcpy_safe( params.m_szName, actor->GetName() );
+
+	if ( !ActorProperties( &params ) )
+		return;
+
+	if ( strlen( params.m_szName ) <= 0 )
+		return;
+
+	SetDirty( true );
+
+	PushUndo( "Edit Actor" );
+
+	actor->SetName( params.m_szName );
+
+	PushRedo( "Edit Actor" );
+
+	// Redraw
+	InvalidateLayout();
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+// Input  : type - 
+//-----------------------------------------------------------------------------
+void CChoreoView::AddEvent( int type, int subtype /*= 0*/, char const *defaultparameters /*= NULL*/ )
+{
+	int mx, my;
+	mx = m_nClickedX;
+	my = m_nClickedY;
+	CChoreoChannelWidget *channel = m_pClickedChannel;
+	if ( !channel || !channel->GetChannel() )
+	{
+		CChoreoActorWidget *actor = m_pClickedActor;
+		if ( actor )
+		{
+			if ( actor->GetNumChannels() <= 0 )
+				return;
+
+			channel = actor->GetChannel( 0 );
+			if ( !channel || !channel->GetChannel() )
+				return;
+		}
+		else
+		{
+			return;
+		}
+	}
+
+	// Convert click position local to this window
+	POINT pt;
+	pt.x = mx;
+	pt.y = my;
+
+	CEventParams params;
+	memset( &params, 0, sizeof( params ) );
+
+	if ( defaultparameters )
+	{
+		Q_strncpy( params.m_szParameters, defaultparameters, sizeof( params.m_szParameters ) );
+	}
+
+	strcpy( params.m_szDialogTitle, "Create Event" );
+
+	params.m_nType = type;
+	params.m_pScene = m_pScene;
+
+	params.m_bFixedLength = false;
+	params.m_bResumeCondition = false;
+	params.m_flStartTime = GetTimeValueForMouse( pt.x );
+	params.m_bCloseCaptionNoAttenuate = false;
+	params.m_bForceShortMovement = false;
+	params.m_bSyncToFollowingGesture = false;
+	params.m_bDisabled = false;
+	params.m_bPlayOverScript = false;
+
+	switch ( type )
+	{
+	case CChoreoEvent::EXPRESSION:
+	case CChoreoEvent::FLEXANIMATION:
+	case CChoreoEvent::GESTURE:
+	case CChoreoEvent::SEQUENCE:
+	case CChoreoEvent::LOOKAT:
+	case CChoreoEvent::MOVETO:
+	case CChoreoEvent::FACE:
+	case CChoreoEvent::SUBSCENE:
+	case CChoreoEvent::INTERRUPT:
+	case CChoreoEvent::GENERIC:
+	case CChoreoEvent::PERMIT_RESPONSES:
+		params.m_bHasEndTime = true;
+		params.m_flEndTime = params.m_flStartTime + 0.5f;
+		if ( type == CChoreoEvent::GESTURE && subtype == 1 )
+		{
+			strcpy( params.m_szDialogTitle, "Create <NULL> Gesture" );
+			strcpy( params.m_szName, "NULL" );
+		}
+		break;
+	case CChoreoEvent::SPEAK:
+		params.m_bFixedLength = true;
+		params.m_bHasEndTime = false;
+		params.m_flEndTime = -1.0f;
+		break;
+	default:
+		params.m_bHasEndTime = false;
+		params.m_flEndTime = -1.0f;
+		break;
+	}
+
+	params.m_bUsesTag = false;
+
+	while (1)
+	{
+		SetScrubTargetTime( m_flScrub );
+		FinishSimulation();
+		sound->Flush();
+
+		m_bForceProcess = true;
+		if (!EventProperties( &params ))
+		{
+			m_bForceProcess = false;
+			return;
+		}
+		m_bForceProcess = false;
+
+		if ( Q_strlen( params.m_szName ) <= 0 )
+		{
+			mxMessageBox( this, va( "Event must have a valid name" ),
+				"Edit Event", MX_MB_OK | MX_MB_ERROR );
+			continue;
+		}
+
+		if ( Q_strlen( params.m_szParameters ) <= 0 )
+		{
+			bool shouldBreak = false;
+
+			switch ( params.m_nType )
+			{
+			case CChoreoEvent::FLEXANIMATION:
+			case CChoreoEvent::INTERRUPT:
+			case CChoreoEvent::PERMIT_RESPONSES:
+				shouldBreak = true;
+				break;
+			case CChoreoEvent::GESTURE:
+				if ( subtype == 1 )
+				{
+					shouldBreak = true;
+				}
+				break;
+			default:
+				// Have to have a non-null parameters block
+				break;
+			}
+			
+			if ( !shouldBreak )
+			{
+				mxMessageBox( this, va( "No parameters specified for %s\n", params.m_szName ),
+					"Edit Event", MX_MB_OK | MX_MB_ERROR );
+				continue;
+			}
+		}
+		
+		break;
+	}
+
+	SetDirty( true );
+
+	PushUndo( "Add Event" );
+
+	CChoreoEvent *event = m_pScene->AllocEvent();
+	if ( event )
+	{
+		event->SetType( (CChoreoEvent::EVENTTYPE)type );
+		event->SetName( params.m_szName );
+		event->SetParameters( params.m_szParameters );
+		event->SetParameters2( params.m_szParameters2 );
+		event->SetParameters3( params.m_szParameters3 );
+		event->SetStartTime( params.m_flStartTime );
+
+		event->SetResumeCondition( params.m_bResumeCondition );
+		event->SetLockBodyFacing( params.m_bLockBodyFacing );
+		event->SetDistanceToTarget( params.m_flDistanceToTarget );
+		event->SetForceShortMovement( params.m_bForceShortMovement );
+		event->SetSyncToFollowingGesture( params.m_bSyncToFollowingGesture );
+		event->SetActive( !params.m_bDisabled );
+		event->SetPlayOverScript( params.m_bPlayOverScript );
+
+		if ( params.m_bUsesTag )
+		{
+			event->SetUsingRelativeTag( true, params.m_szTagName, params.m_szTagWav );
+		}
+		else
+		{
+			event->SetUsingRelativeTag( false );
+		}
+		CChoreoChannel *pchannel = channel->GetChannel();
+
+		event->SetChannel( pchannel );
+		event->SetActor( pchannel->GetActor() );
+
+		if ( params.m_bHasEndTime &&
+			params.m_flEndTime != -1.0 &&
+			params.m_flEndTime > params.m_flStartTime )
+		{
+			event->SetEndTime( params.m_flEndTime );
+		}
+		else
+		{
+			event->SetEndTime( -1.0f );
+		}
+
+		switch ( event->GetType() )
+		{
+		default:
+			break;
+		case CChoreoEvent::SUBSCENE:
+			{
+				// Just grab end time
+				CChoreoScene *scene = LoadScene( event->GetParameters() );
+				if ( scene )
+				{
+					event->SetEndTime( params.m_flStartTime + scene->FindStopTime() );
+				}
+				delete scene;
+			}
+			break;
+		case CChoreoEvent::SEQUENCE:
+			{
+				CheckSequenceLength( event, false );
+				// AutoaddSequenceKeys( event);
+			}
+			break;
+		case CChoreoEvent::GESTURE:
+			{
+				DefaultGestureLength( event, false );
+				AutoaddGestureKeys( event, false );
+			}
+			break;
+		case CChoreoEvent::LOOKAT:
+		case CChoreoEvent::FACE:
+			{
+				if ( params.usepitchyaw )
+				{
+					event->SetPitch( params.pitch );
+					event->SetYaw( params.yaw );
+				}
+				else
+				{
+					event->SetPitch( 0 );
+					event->SetYaw( 0 );
+				}
+			}
+			break;
+		case CChoreoEvent::SPEAK:
+			{
+				// Try and load wav to get length
+				CAudioSource *wave = sound->LoadSound( va( "sound/%s", FacePoser_TranslateSoundName( event ) ) );
+				if ( wave )
+				{
+					event->SetEndTime( params.m_flStartTime + wave->GetRunningLength() );
+					delete wave;
+				}
+
+				event->SetSuppressingCaptionAttenuation( params.m_bCloseCaptionNoAttenuate );
+			}
+			break;
+		}
+		event->SnapTimes();
+
+		DeleteSceneWidgets();
+
+		// Add to appropriate channel
+		pchannel->AddEvent( event );
+
+		CreateSceneWidgets();
+
+		// Redraw
+		InvalidateLayout();
+	}
+
+	PushRedo( "Add Event" );
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: Adds a scene "pause" event
+//-----------------------------------------------------------------------------
+void CChoreoView::AddGlobalEvent( CChoreoEvent::EVENTTYPE type )
+{
+	int mx, my;
+	mx = m_nClickedX;
+	my = m_nClickedY;
+
+	// Convert click position local to this window
+	POINT pt;
+	pt.x = mx;
+	pt.y = my;
+
+	CGlobalEventParams params;
+	memset( &params, 0, sizeof( params ) );
+
+	params.m_nType = type;
+
+	switch ( type )
+	{
+	default:
+		Assert( 0 );
+		strcpy( params.m_szDialogTitle, "???" );
+		break;
+	case CChoreoEvent::SECTION:
+		{
+			strcpy( params.m_szDialogTitle, "Add Pause Point" );
+		}
+		break;
+	case CChoreoEvent::LOOP:
+		{
+			strcpy( params.m_szDialogTitle, "Add Loop Point" );
+		}
+		break;
+	case CChoreoEvent::STOPPOINT:
+		{
+			strcpy( params.m_szDialogTitle, "Add Fire Completion" );
+		}
+		break;
+	}
+	strcpy( params.m_szName, "" );
+	strcpy( params.m_szAction, "" );
+
+	params.m_flStartTime = GetTimeValueForMouse( pt.x );
+
+	if ( !GlobalEventProperties( &params ) )
+		return;
+
+	if ( strlen( params.m_szName ) <= 0 )
+	{
+		Con_Printf( "Pause section event must have a valid name\n" );
+		return;
+	}
+
+	if ( strlen( params.m_szAction ) <= 0 )
+	{
+		Con_Printf( "No action specified for section pause\n" );
+		return;
+	}
+
+	char undotext[ 256 ];
+	undotext[0]=0;
+	switch( type )
+	{
+	default:
+		Assert( 0 );
+		break;
+	case CChoreoEvent::SECTION:
+		{
+			Q_strcpy( undotext, "Add Section Pause" );
+		}
+		break;
+	case CChoreoEvent::LOOP:
+		{
+			Q_strcpy( undotext, "Add Loop Point" );
+		}
+		break;
+	case CChoreoEvent::STOPPOINT:
+		{
+			Q_strcpy( undotext, "Add Fire Completion" );
+		}
+		break;
+	}
+
+	SetDirty( true );
+
+	PushUndo( undotext );
+
+	CChoreoEvent *event = m_pScene->AllocEvent();
+	if ( event )
+	{
+		event->SetType( type );
+		event->SetName( params.m_szName );
+		event->SetParameters( params.m_szAction );
+		event->SetStartTime( params.m_flStartTime );
+		event->SetEndTime( -1.0f );
+
+		switch ( type )
+		{
+		default:
+			break;
+		case CChoreoEvent::LOOP:
+			{
+				event->SetLoopCount( params.m_nLoopCount );
+				event->SetParameters( va( "%f", params.m_flLoopTime ) );
+			}
+			break;
+		}
+
+		event->SnapTimes();
+
+		DeleteSceneWidgets();
+
+		CreateSceneWidgets();
+
+		// Redraw
+		InvalidateLayout();
+	}
+
+	PushRedo( undotext );
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+// Input  : *event - 
+//-----------------------------------------------------------------------------
+void CChoreoView::EditGlobalEvent( CChoreoEvent *event )
+{
+	if ( !event )
+		return;
+
+	CGlobalEventParams params;
+	memset( &params, 0, sizeof( params ) );
+
+	params.m_nType = event->GetType();
+
+	switch ( event->GetType() )
+	{
+	default:
+		Assert( 0 );
+		strcpy( params.m_szDialogTitle, "???" );
+		break;
+	case CChoreoEvent::SECTION:
+		{
+			strcpy( params.m_szDialogTitle, "Edit Pause Point" );
+			V_strcpy_safe( params.m_szAction, event->GetParameters() );
+		}
+		break;
+	case CChoreoEvent::LOOP:
+		{
+			strcpy( params.m_szDialogTitle, "Edit Loop Point" );
+			strcpy( params.m_szAction, "" );
+			params.m_flLoopTime = (float)atof( event->GetParameters() );
+			params.m_nLoopCount = event->GetLoopCount();
+		}
+		break;
+	case CChoreoEvent::STOPPOINT:
+		{
+			strcpy( params.m_szDialogTitle, "Edit Fire Completion" );
+			strcpy( params.m_szAction, "" );
+		}
+		break;
+	}
+
+	strcpy( params.m_szName, event->GetName() );
+
+	params.m_flStartTime = event->GetStartTime();
+
+	if ( !GlobalEventProperties( &params ) )
+		return;
+
+	if ( strlen( params.m_szName ) <= 0 )
+	{
+		Con_Printf( "Event %s must have a valid name\n", event->GetName() );
+		return;
+	}
+
+	if ( strlen( params.m_szAction ) <= 0 )
+	{
+		Con_Printf( "No action specified for %s\n", event->GetName() );
+		return;
+	}
+
+	SetDirty( true );
+
+	char undotext[ 256 ];
+	undotext[0]=0;
+	switch( event->GetType() )
+	{
+	default:
+		Assert( 0 );
+		break;
+	case CChoreoEvent::SECTION:
+		{
+			Q_strcpy( undotext, "Edit Section Pause" );
+		}
+		break;
+	case CChoreoEvent::LOOP:
+		{
+			Q_strcpy( undotext, "Edit Loop Point" );
+		}
+		break;
+	case CChoreoEvent::STOPPOINT:
+		{
+			Q_strcpy( undotext, "Edit Fire Completion" );
+		}
+		break;
+	}
+
+	PushUndo( undotext );
+
+	event->SetName( params.m_szName );
+	event->SetStartTime( params.m_flStartTime );
+	event->SetEndTime( -1.0f );
+
+	switch ( event->GetType() )
+	{
+	default:
+		{
+			event->SetParameters( params.m_szAction );
+		}
+		break;
+	case CChoreoEvent::LOOP:
+		{
+			event->SetLoopCount( params.m_nLoopCount );
+			event->SetParameters( va( "%f", params.m_flLoopTime ) );
+		}
+		break;
+	}
+
+	event->SnapTimes();
+
+	PushRedo( undotext );
+
+	// Redraw
+	InvalidateLayout();
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+// Input  : *event - 
+//-----------------------------------------------------------------------------
+void CChoreoView::DeleteGlobalEvent( CChoreoEvent *event )
+{
+	if ( !event || !m_pScene )
+		return;
+
+	SetDirty( true );
+
+
+	char undotext[ 256 ];
+	undotext[0]=0;
+	switch( event->GetType() )
+	{
+	default:
+		Assert( 0 );
+		break;
+	case CChoreoEvent::SECTION:
+		{
+			Q_strcpy( undotext, "Delete Section Pause" );
+		}
+		break;
+	case CChoreoEvent::LOOP:
+		{
+			Q_strcpy( undotext, "Delete Loop Point" );
+		}
+		break;
+	case CChoreoEvent::STOPPOINT:
+		{
+			Q_strcpy( undotext, "Delete Fire Completion" );
+		}
+		break;
+	}
+
+	PushUndo( undotext );
+
+	DeleteSceneWidgets();
+
+	Con_Printf( "Deleting %s\n", event->GetName() );
+
+	m_pScene->DeleteReferencedObjects( event );
+
+	CreateSceneWidgets();
+
+	PushRedo( undotext );
+
+	// Redraw
+	InvalidateLayout();
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+// Input  : *event - 
+//-----------------------------------------------------------------------------
+void CChoreoView::EditEvent( CChoreoEvent *event )
+{
+	if ( !event )
+		return;
+
+	CEventParams params;
+	memset( &params, 0, sizeof( params ) );
+
+	strcpy( params.m_szDialogTitle, "Edit Event" );
+
+	// Copy in current even properties
+	params.m_nType = event->GetType();
+	params.m_bDisabled = !event->GetActive();
+
+	switch ( params.m_nType )
+	{
+		case CChoreoEvent::EXPRESSION:
+		case CChoreoEvent::SEQUENCE:
+		case CChoreoEvent::MOVETO:
+		case CChoreoEvent::SPEAK:
+		case CChoreoEvent::GESTURE:
+		case CChoreoEvent::INTERRUPT:
+		case CChoreoEvent::PERMIT_RESPONSES:
+		case CChoreoEvent::GENERIC:
+			V_strcpy_safe( params.m_szParameters3, event->GetParameters3() );
+			V_strcpy_safe( params.m_szParameters2, event->GetParameters2() );
+			V_strcpy_safe( params.m_szParameters, event->GetParameters() );
+			V_strcpy_safe( params.m_szName, event->GetName() );
+			break;
+		case CChoreoEvent::FACE:
+		case CChoreoEvent::LOOKAT:
+		case CChoreoEvent::FIRETRIGGER:
+		case CChoreoEvent::FLEXANIMATION:
+		case CChoreoEvent::SUBSCENE:
+			V_strcpy_safe( params.m_szParameters, event->GetParameters() );
+			V_strcpy_safe( params.m_szName, event->GetName() );
+
+			if ( params.m_nType == CChoreoEvent::LOOKAT || params.m_nType == CChoreoEvent::FACE )
+			{
+				if ( event->GetPitch() != 0 ||
+					 event->GetYaw() != 0 )
+				{
+					params.usepitchyaw = true;
+					params.pitch = event->GetPitch();
+					params.yaw = event->GetYaw();
+				}
+			}
+			break;
+		default:
+			Con_Printf( "Don't know how to edit event type %s\n",
+				CChoreoEvent::NameForType( (CChoreoEvent::EVENTTYPE)params.m_nType ) );
+			return;
+	}
+
+	params.m_pScene = m_pScene;
+	params.m_pEvent = event;
+	params.m_flStartTime = event->GetStartTime();
+	params.m_flEndTime = event->GetEndTime();
+	params.m_bHasEndTime = event->HasEndTime();
+
+	params.m_bFixedLength = event->IsFixedLength();
+	params.m_bResumeCondition = event->IsResumeCondition();
+	params.m_bLockBodyFacing = event->IsLockBodyFacing();
+	params.m_flDistanceToTarget = event->GetDistanceToTarget();
+	params.m_bForceShortMovement = event->GetForceShortMovement();
+	params.m_bSyncToFollowingGesture = event->GetSyncToFollowingGesture();
+	params.m_bPlayOverScript = event->GetPlayOverScript();
+	params.m_bUsesTag = event->IsUsingRelativeTag();
+	params.m_bCloseCaptionNoAttenuate = event->IsSuppressingCaptionAttenuation();
+
+	if ( params.m_bUsesTag )
+	{
+		V_strcpy_safe( params.m_szTagName, event->GetRelativeTagName() );
+		V_strcpy_safe( params.m_szTagWav, event->GetRelativeWavName() );
+	}
+
+	while (1)
+	{
+		SetScrubTargetTime( m_flScrub );
+		FinishSimulation();
+		sound->Flush();
+
+		m_bForceProcess = true;
+		if (!EventProperties( &params ))
+		{
+			m_bForceProcess = false;
+			return;
+		}
+		m_bForceProcess = false;
+
+		if ( Q_strlen( params.m_szName ) <= 0 )
+		{
+			mxMessageBox( this, va( "Event %s must have a valid name", event->GetName() ),
+				"Edit Event", MX_MB_OK | MX_MB_ERROR );
+			continue;
+		}
+
+		if ( Q_strlen( params.m_szParameters ) <= 0 )
+		{
+			bool shouldBreak = false;
+
+			switch ( params.m_nType )
+			{
+			case CChoreoEvent::FLEXANIMATION:
+			case CChoreoEvent::INTERRUPT:
+			case CChoreoEvent::PERMIT_RESPONSES:
+				shouldBreak = true;
+				break;
+			case CChoreoEvent::GESTURE:
+				if ( !Q_stricmp( params.m_szName, "NULL" ) )
+				{ 
+					shouldBreak = true;
+				}
+				break;
+			default:
+				// Have to have a non-null parameters block
+				break;
+			}
+			
+			if ( !shouldBreak )
+			{
+				mxMessageBox( this, va( "No parameters specified for %s\n", params.m_szName ),
+					"Edit Event", MX_MB_OK | MX_MB_ERROR );
+				continue;
+			}
+		}
+		
+		break;
+	}
+
+
+	SetDirty( true );
+
+	PushUndo( "Edit Event" );
+
+	event->SetName( params.m_szName );
+	event->SetParameters( params.m_szParameters );
+	event->SetParameters2( params.m_szParameters2 );
+	event->SetParameters3( params.m_szParameters3 );
+	event->SetStartTime( params.m_flStartTime );
+	event->SetResumeCondition( params.m_bResumeCondition );
+	event->SetLockBodyFacing( params.m_bLockBodyFacing );
+	event->SetDistanceToTarget( params.m_flDistanceToTarget );
+	event->SetForceShortMovement( params.m_bForceShortMovement );
+	event->SetSyncToFollowingGesture( params.m_bSyncToFollowingGesture );
+	event->SetActive( !params.m_bDisabled );
+	event->SetPlayOverScript( params.m_bPlayOverScript );
+	if ( params.m_bUsesTag )
+	{
+		event->SetUsingRelativeTag( true, params.m_szTagName, params.m_szTagWav );
+	}
+	else
+	{
+		event->SetUsingRelativeTag( false );
+	}
+
+	if ( params.m_bHasEndTime &&
+		params.m_flEndTime != -1.0 &&
+		params.m_flEndTime > params.m_flStartTime )
+	{
+		float dt = params.m_flEndTime - event->GetEndTime();
+		float newduration = event->GetDuration() + dt;
+		RescaleRamp( event, newduration );
+		switch ( event->GetType() )
+		{
+		default:
+			break;
+		case CChoreoEvent::GESTURE:
+			{
+				event->RescaleGestureTimes( event->GetStartTime(), event->GetEndTime() + dt, true );
+			}
+			break;
+		case CChoreoEvent::FLEXANIMATION:
+			{
+				RescaleExpressionTimes( event, event->GetStartTime(), event->GetEndTime() + dt );
+			}
+			break;
+		}
+		event->SetEndTime( params.m_flEndTime );
+		event->SnapTimes();
+		event->ResortRamp();
+	}
+	else
+	{
+		event->SetEndTime( -1.0f );
+	}
+
+	switch ( event->GetType() )
+	{
+	default:
+		break;
+	case CChoreoEvent::SPEAK:
+		{
+			// Try and load wav to get length
+			CAudioSource *wave = sound->LoadSound( va( "sound/%s", FacePoser_TranslateSoundName( event ) ) );
+			if ( wave )
+			{
+				event->SetEndTime( params.m_flStartTime + wave->GetRunningLength() );
+				delete wave;
+			}
+
+			event->SetSuppressingCaptionAttenuation( params.m_bCloseCaptionNoAttenuate );
+		}
+		break;
+	case CChoreoEvent::SUBSCENE:
+		{
+			// Just grab end time
+			CChoreoScene *scene = LoadScene( event->GetParameters() );
+			if ( scene )
+			{
+				event->SetEndTime( params.m_flStartTime + scene->FindStopTime() );
+			}
+			delete scene;
+		}
+		break;
+	case CChoreoEvent::SEQUENCE:
+		{
+			CheckSequenceLength( event, false );
+		}
+		break;
+	case CChoreoEvent::GESTURE:
+		{
+			CheckGestureLength( event, false );
+			AutoaddGestureKeys( event, false );
+			g_pGestureTool->redraw();
+		}
+		break;
+	case CChoreoEvent::LOOKAT:
+	case CChoreoEvent::FACE:
+		{
+			if ( params.usepitchyaw )
+			{
+				event->SetPitch( params.pitch );
+				event->SetYaw( params.yaw );
+			}
+			else
+			{
+				event->SetPitch( 0 );
+				event->SetYaw( 0 );
+			}
+		}
+		break;
+	}
+
+	event->SnapTimes();
+
+	PushRedo( "Edit Event" );
+
+	// Redraw
+	InvalidateLayout();
+}
+
+void CChoreoView::EnableSelectedEvents( bool state )
+{
+	if ( !m_pScene )
+		return;
+
+	SetDirty( true );
+
+	// If we right clicked on an unseleced event, then select it for the user.
+	if ( CountSelectedEvents() == 0 )
+	{
+		CChoreoEventWidget *event = m_pClickedEvent;
+		if ( event )
+		{
+			event->SetSelected( true );
+		}
+	}
+
+	char const *desc = state ? "Enable Events" : "Disable Events";
+
+	PushUndo( desc );
+
+	// Find the appropriate event by iterating across all actors and channels
+	for ( int i = 0; i < m_SceneActors.Size(); i++ )
+	{
+		CChoreoActorWidget *a = m_SceneActors[ i ];
+		if ( !a )
+			continue;
+
+		for ( int j = 0; j < a->GetNumChannels(); j++ )
+		{
+			CChoreoChannelWidget *channel = a->GetChannel( j );
+			if ( !channel )
+				continue;
+
+			for ( int k = channel->GetNumEvents() - 1; k >= 0; k-- )
+			{
+				CChoreoEventWidget *event = channel->GetEvent( k );
+				if ( !event->IsSelected() )
+					continue;
+
+				event->GetEvent()->SetActive( state );
+			}
+		}
+	}
+
+	for ( int i = 0; i < m_SceneGlobalEvents.Size(); i++ )
+	{
+		CChoreoGlobalEventWidget *event = m_SceneGlobalEvents[ i ];
+		if ( !event || !event->IsSelected() )
+			continue;
+
+		event->GetEvent()->SetActive( state );
+	}
+
+	PushRedo( desc );
+
+	// Redraw
+	InvalidateLayout();
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+// Input  : *event - 
+//-----------------------------------------------------------------------------
+void CChoreoView::DeleteSelectedEvents( void )
+{
+	if ( !m_pScene )
+		return;
+
+	SetDirty( true );
+
+	PushUndo( "Delete Events" );
+
+	int deleteCount = 0;
+
+	float oldstoptime = m_pScene->FindStopTime();
+
+	// Find the appropriate event by iterating across all actors and channels
+	for ( int i = 0; i < m_SceneActors.Size(); i++ )
+	{
+		CChoreoActorWidget *a = m_SceneActors[ i ];
+		if ( !a )
+			continue;
+
+		for ( int j = 0; j < a->GetNumChannels(); j++ )
+		{
+			CChoreoChannelWidget *channel = a->GetChannel( j );
+			if ( !channel )
+				continue;
+
+			for ( int k = channel->GetNumEvents() - 1; k >= 0; k-- )
+			{
+				CChoreoEventWidget *event = channel->GetEvent( k );
+				if ( !event->IsSelected() )
+					continue;
+
+				channel->GetChannel()->RemoveEvent( event->GetEvent() );
+				m_pScene->DeleteReferencedObjects( event->GetEvent() );
+
+				deleteCount++;
+			}
+		}
+	}
+
+	for ( int i = 0; i < m_SceneGlobalEvents.Size(); i++ )
+	{
+		CChoreoGlobalEventWidget *event = m_SceneGlobalEvents[ i ];
+		if ( !event || !event->IsSelected() )
+			continue;
+
+		m_pScene->DeleteReferencedObjects( event->GetEvent() );
+
+		deleteCount++;
+	}
+
+	DeleteSceneWidgets();
+
+	ReportSceneClearToTools();
+
+	CreateSceneWidgets();
+
+	PushRedo( "Delete Events" );
+
+	Con_Printf( "Deleted <%i> events\n", deleteCount );
+
+	if ( m_pScene->FindStopTime() != oldstoptime )
+	{
+		// Force scroll bars to recompute
+		ForceScrollBarsToRecompute( false );
+
+	}
+	// Redraw
+	InvalidateLayout();
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+// Input  : resetthumb - 
+//-----------------------------------------------------------------------------
+void CChoreoView::ForceScrollBarsToRecompute( bool resetthumb )
+{
+	if ( resetthumb )
+	{
+		m_flLeftOffset = 0.0f;
+	}
+	m_nLastHPixelsNeeded = -1;
+	m_nLastVPixelsNeeded = -1;
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+// Input  : *filename - 
+// Output : CChoreoScene
+//-----------------------------------------------------------------------------
+CChoreoScene *CChoreoView::LoadScene( char const *filename )
+{
+	// If relative path, then make a full path
+	char pFullPathBuf[ MAX_PATH ];
+	if ( !Q_IsAbsolutePath( filename ) )
+	{
+		filesystem->RelativePathToFullPath( filename, "GAME", pFullPathBuf, sizeof( pFullPathBuf ) );
+		filename = pFullPathBuf;
+	}
+
+	if ( !filesystem->FileExists( filename ) )
+		return NULL;
+
+	LoadScriptFile( const_cast<char*>( filename ) );
+
+	CChoreoScene *scene = ChoreoLoadScene( filename, this, tokenprocessor, Con_Printf );
+	return scene;
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+bool CChoreoView::FixupSequenceDurations( CChoreoScene *scene, bool checkonly )
+{
+	bool bret = false;
+	if ( !scene )
+		return bret;
+
+	int c = scene->GetNumEvents();
+	for ( int i = 0; i < c; i++ )
+	{
+		CChoreoEvent *event = scene->GetEvent( i );
+		if ( !event )
+			continue;
+
+		switch ( event->GetType() )
+		{
+		default:
+			break;
+		case CChoreoEvent::SPEAK:
+			{
+				// Try and load wav to get length
+				CAudioSource *wave = sound->LoadSound( va( "sound/%s", FacePoser_TranslateSoundName( event ) ) );
+				if ( wave )
+				{
+					float endtime = event->GetStartTime() + wave->GetRunningLength();
+					if ( event->GetEndTime() != endtime )
+					{
+						event->SetEndTime( event->GetStartTime() + wave->GetRunningLength() );
+						bret = true;
+					}
+					delete wave;
+				}
+			}
+			break;
+		case CChoreoEvent::SEQUENCE:
+			{
+				if ( CheckSequenceLength( event, checkonly ) )
+				{
+					bret = true;
+				}
+			}
+			break;
+		case CChoreoEvent::GESTURE:
+			{
+				if ( CheckGestureLength( event, checkonly ) )
+				{
+					bret = true;
+				}
+				if ( AutoaddGestureKeys( event, checkonly ) )
+				{
+					bret = true;
+				}
+			}
+			break;
+		}
+	}
+
+	return bret;
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: IChoreoEventCallback
+// Input  : currenttime - 
+//			*event - 
+//-----------------------------------------------------------------------------
+void CChoreoView::StartEvent( float currenttime, CChoreoScene *scene, CChoreoEvent *event )
+{
+	if ( !event || !event->GetActive() )
+		return;
+
+	CChoreoActor *actor = event->GetActor();
+	if ( actor && !actor->GetActive() )
+	{
+		return;
+	}
+
+	CChoreoChannel *channel = event->GetChannel();
+	if ( channel && !channel->GetActive() )
+	{
+		return;
+	}
+
+	// Con_Printf( "%8.4f:  start %s\n", currenttime, event->GetDescription() );
+
+	switch ( event->GetType() )
+	{
+	case CChoreoEvent::SEQUENCE:
+		{
+			ProcessSequence( scene, event );
+		}
+		break;
+	case CChoreoEvent::SUBSCENE:
+		{
+			if ( !scene->IsSubScene() )
+			{
+				CChoreoScene *subscene = event->GetSubScene();
+				if ( !subscene )
+				{
+					subscene = LoadScene( event->GetParameters() );
+					subscene->SetSubScene( true );
+					event->SetSubScene( subscene );
+				}
+
+				if ( subscene )
+				{
+					subscene->ResetSimulation( m_bForward );
+				}
+			}
+		}
+		break;
+	case CChoreoEvent::SECTION:
+		{
+			ProcessPause( scene, event );
+		}
+		break;
+	case CChoreoEvent::SPEAK:
+		{
+			if ( ShouldProcessSpeak() )
+			{
+				// See if we should trigger CC
+				char soundname[ 512 ];
+				Q_strncpy( soundname, event->GetParameters(), sizeof( soundname ) );
+
+				float actualEndTime = event->GetEndTime();
+
+				if ( event->GetCloseCaptionType() == CChoreoEvent::CC_MASTER )
+				{
+					char tok[ CChoreoEvent::MAX_CCTOKEN_STRING ];
+					if ( event->GetPlaybackCloseCaptionToken( tok, sizeof( tok ) ) )
+					{
+						float duration = max( event->GetDuration(), event->GetLastSlaveEndTime() - event->GetStartTime() );
+
+						closecaptionmanager->Process( tok, duration, GetCloseCaptionLanguageId() );
+
+						// Use the token as the sound name lookup, too.
+						if ( event->IsUsingCombinedFile() &&
+							 ( event->GetNumSlaves() > 0 ) ) 
+						{
+							Q_strncpy( soundname, tok, sizeof( soundname ) );
+							actualEndTime = max( actualEndTime, event->GetLastSlaveEndTime() );
+						}
+					}
+				}
+
+				StudioModel *model = FindAssociatedModel( scene, event->GetActor() );
+
+				CAudioMixer *mixer = event->GetMixer();
+				if ( !mixer || !sound->IsSoundPlaying( mixer ) )
+				{
+					CSoundParameters params;
+
+					float volume = VOL_NORM;
+					gender_t gender = GENDER_NONE;
+					if (model)
+					{
+						gender = soundemitter->GetActorGender( model->GetFileName() );
+					}
+					
+					if ( !Q_stristr( soundname, ".wav" ) &&
+						soundemitter->GetParametersForSound( soundname, params, gender ) )
+					{
+						volume = params.volume;
+					}
+
+					sound->PlaySound( 
+						model, 
+						volume,
+						va( "sound/%s", FacePoser_TranslateSoundName( soundname, model ) ),
+						&mixer );
+					event->SetMixer( mixer );
+				}
+
+				if ( mixer )
+				{
+					mixer->SetDirection( m_flFrameTime >= 0.0f );
+					float starttime, endtime;
+					starttime = event->GetStartTime();
+					endtime = actualEndTime;
+
+					float soundtime = endtime - starttime;
+					if ( soundtime > 0.0f )
+					{
+						float f = ( currenttime - starttime ) / soundtime;
+						f = clamp( f, 0.0f, 1.0f );
+
+						// Compute sample
+						float numsamples = (float)mixer->GetSource()->SampleCount();
+
+						int cursample = f * numsamples;
+						cursample = clamp( cursample, 0, numsamples - 1 );
+						mixer->SetSamplePosition( cursample );
+						mixer->SetActive( true );
+					}
+				}
+			}
+		}
+		break;
+	case CChoreoEvent::EXPRESSION:
+		{
+		}
+		break;
+	case CChoreoEvent::LOOP:
+		{
+			ProcessLoop( scene, event );
+		}
+		break;
+	case CChoreoEvent::STOPPOINT:
+		{
+			// Nothing, this is a symbolic event for keeping the vcd alive for ramping out after the last true event
+		}
+		break;
+	default:
+		break;
+	}
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+// Input  : currenttime - 
+//			*event - 
+//-----------------------------------------------------------------------------
+void CChoreoView::EndEvent( float currenttime, CChoreoScene *scene, CChoreoEvent *event )
+{
+	if ( !event || !event->GetActive() )
+		return;
+
+	CChoreoActor *actor = event->GetActor();
+	if ( actor && !actor->GetActive() )
+	{
+		return;
+	}
+
+	CChoreoChannel *channel = event->GetChannel();
+	if ( channel && !channel->GetActive() )
+	{
+		return;
+	}
+
+	switch ( event->GetType() )
+	{
+	case CChoreoEvent::SUBSCENE:
+		{
+			CChoreoScene *subscene = event->GetSubScene();
+			if ( subscene )
+			{
+				subscene->ResetSimulation();
+			}
+		}
+		break;
+	case CChoreoEvent::SPEAK:
+		{
+			CAudioMixer *mixer = event->GetMixer();
+			if ( mixer && sound->IsSoundPlaying( mixer ) )
+			{
+				sound->StopSound( mixer );
+			}
+			event->SetMixer( NULL );
+		}
+		break;
+	default:
+		break;
+	}
+
+//	Con_Printf( "%8.4f:  finish %s\n", currenttime, event->GetDescription() );
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+// Input  : *event - 
+//			mx - 
+//			my - 
+//-----------------------------------------------------------------------------
+int CChoreoView::GetTagUnderCursorPos( CChoreoEventWidget *event, int mx, int my )
+{
+	if ( !event )
+	{
+		return -1;
+	}
+
+	for ( int i = 0; i < event->GetEvent()->GetNumRelativeTags(); i++ )
+	{
+		CEventRelativeTag *tag = event->GetEvent()->GetRelativeTag( i );
+		if ( !tag )
+			continue;
+
+		// Determine left edcge
+		RECT bounds;
+		bounds = event->getBounds();
+		int left = bounds.left + (int)( tag->GetPercentage() * (float)( bounds.right - bounds.left ) + 0.5f );
+
+		int tolerance = 3;
+
+		if ( abs( mx - left ) < tolerance )
+		{
+			if ( abs( my - bounds.top ) < tolerance )
+			{
+				return i;
+			}
+		}
+	}
+
+	return -1;
+}
+
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+// Input  : *event - 
+//			mx - 
+//			my - 
+//-----------------------------------------------------------------------------
+CEventAbsoluteTag *CChoreoView::GetAbsoluteTagUnderCursorPos( CChoreoEventWidget *event, int mx, int my )
+{
+	if ( !event )
+	{
+		return NULL;
+	}
+
+	for ( int i = 0; i < event->GetEvent()->GetNumAbsoluteTags( CChoreoEvent::PLAYBACK ); i++ )
+	{
+		CEventAbsoluteTag *tag = event->GetEvent()->GetAbsoluteTag( CChoreoEvent::PLAYBACK, i );
+		if ( !tag )
+			continue;
+
+		// Determine left edcge
+		RECT bounds;
+		bounds = event->getBounds();
+		int left = bounds.left + (int)( tag->GetPercentage() * (float)( bounds.right - bounds.left ) + 0.5f );
+
+		int tolerance = 3;
+
+		if ( abs( mx - left ) < tolerance )
+		{
+			if ( abs( my - bounds.top ) < tolerance )
+			{
+				return tag;
+			}
+		}
+	}
+
+	return NULL;
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+// Input  : mx - 
+//			my - 
+//			**actor - 
+//			**channel - 
+//			**event - 
+//-----------------------------------------------------------------------------
+void CChoreoView::GetObjectsUnderMouse( int mx, int my, CChoreoActorWidget **actor,
+	CChoreoChannelWidget **channel, CChoreoEventWidget **event, CChoreoGlobalEventWidget **globalevent,
+	int *clickedTag,
+	CEventAbsoluteTag **absolutetag, int *clickedCCArea )
+{
+	if ( actor )
+	{
+		*actor = GetActorUnderCursorPos( mx, my );
+	}
+	if ( channel )
+	{
+		*channel = GetChannelUnderCursorPos( mx, my );
+		if ( *channel && clickedCCArea )
+		{
+			*clickedCCArea = (*channel)->GetChannelItemUnderMouse( mx, my );
+		}
+	}
+	if ( event )
+	{
+		*event = GetEventUnderCursorPos( mx, my );
+	}
+	if ( globalevent )
+	{
+		*globalevent = GetGlobalEventUnderCursorPos( mx, my );
+	}
+	if ( clickedTag )
+	{
+		if ( event && *event )
+		{
+			*clickedTag = GetTagUnderCursorPos( *event, mx, my );
+		}
+		else
+		{
+			*clickedTag = -1;
+		}
+	}
+	if ( absolutetag )
+	{
+		if ( event && *event )
+		{
+			*absolutetag = GetAbsoluteTagUnderCursorPos( *event, mx, my );
+		}
+		else
+		{
+			*absolutetag = NULL;
+		}
+	}
+
+
+	m_nSelectedEvents = CountSelectedEvents();
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+// Input  : mx - 
+//			my - 
+// Output : CChoreoGlobalEventWidget
+//-----------------------------------------------------------------------------
+CChoreoGlobalEventWidget *CChoreoView::GetGlobalEventUnderCursorPos( int mx, int my )
+{
+	POINT check;
+	check.x = mx;
+	check.y = my;
+
+	CChoreoGlobalEventWidget *event;
+	for ( int i = 0; i < m_SceneGlobalEvents.Size(); i++ )
+	{
+		event = m_SceneGlobalEvents[ i ];
+		if ( !event )
+			continue;
+
+		RECT bounds;
+		event->getBounds( bounds );
+
+		if ( PtInRect( &bounds, check ) )
+		{
+			return event;
+		}
+	}
+
+	return NULL;
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: Caller must first translate mouse into screen coordinates
+// Input  : mx - 
+//			my - 
+//-----------------------------------------------------------------------------
+CChoreoActorWidget *CChoreoView::GetActorUnderCursorPos( int mx, int my )
+{
+	POINT check;
+	check.x = mx;
+	check.y = my;
+
+	CChoreoActorWidget *actor;
+	for ( int i = 0; i < m_SceneActors.Size(); i++ )
+	{
+		actor = m_SceneActors[ i ];
+		if ( !actor )
+			continue;
+
+		RECT bounds;
+		actor->getBounds( bounds );
+
+		if ( PtInRect( &bounds, check ) )
+		{
+			return actor;
+		}
+	}
+
+	return NULL;
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: Caller must first translate mouse into screen coordinates
+// Input  : mx - 
+//			my - 
+// Output : CChoreoChannelWidget
+//-----------------------------------------------------------------------------
+CChoreoChannelWidget *CChoreoView::GetChannelUnderCursorPos( int mx, int my )
+{
+	CChoreoActorWidget *actor = GetActorUnderCursorPos( mx, my );
+	if ( !actor )
+	{
+		return NULL;
+	}
+
+	POINT check;
+	check.x = mx;
+	check.y = my;
+
+	CChoreoChannelWidget *channel;
+	for ( int i = 0; i < actor->GetNumChannels(); i++ )
+	{
+		channel = actor->GetChannel( i );
+		if ( !channel )
+			continue;
+
+		RECT bounds;
+		channel->getBounds( bounds );
+
+		if ( PtInRect( &bounds, check ) )
+		{
+			return channel;
+		}
+	}
+
+	return NULL;
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: Caller must first translate mouse into screen coordinates
+// Input  : mx - 
+//			my - 
+//-----------------------------------------------------------------------------
+CChoreoEventWidget *CChoreoView::GetEventUnderCursorPos( int mx, int my )
+{
+	CChoreoChannelWidget *channel = GetChannelUnderCursorPos( mx, my );
+	if ( !channel )
+	{
+		return NULL;
+	}
+
+	POINT check;
+	check.x = mx;
+	check.y = my;
+
+	if ( mx < GetLabelWidth() )
+		return NULL;
+
+	if ( my < GetStartRow() )
+		return NULL;
+
+	if ( my >= h2() - ( m_nInfoHeight + m_nScrollbarHeight ) )
+		return NULL;
+
+	CChoreoEventWidget *event;
+	for ( int i = 0; i < channel->GetNumEvents(); i++ )
+	{
+		event = channel->GetEvent( i );
+		if ( !event )
+			continue;
+
+		RECT bounds;
+		event->getBounds( bounds );
+
+		// Events get an expanded border
+		InflateRect( &bounds, 8, 4 );
+
+		if ( PtInRect( &bounds, check ) )
+		{
+			return event;
+		}
+	}
+
+	return NULL;
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: Select wave file for phoneme editing
+// Input  : *filename - 
+//-----------------------------------------------------------------------------
+void CChoreoView::SetCurrentWaveFile( const char *filename, CChoreoEvent *event )
+{
+	g_pPhonemeEditor->SetCurrentWaveFile( filename, false, event );
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+// Input  : pfn - 
+//			*param1 - 
+//-----------------------------------------------------------------------------
+void CChoreoView::TraverseWidgets( CVMEMBERFUNC pfn, CChoreoWidget *param1 )
+{
+	for ( int i = 0; i < m_SceneActors.Size(); i++ )
+	{
+		CChoreoActorWidget *actor = m_SceneActors[ i ];
+		if ( !actor )
+			continue;
+
+		(this->*pfn)( actor, param1 );
+
+		for ( int j = 0; j < actor->GetNumChannels(); j++ )
+		{
+			CChoreoChannelWidget *channel = actor->GetChannel( j );
+			if ( !channel )
+				continue;
+
+			(this->*pfn)( channel, param1 );
+
+			for ( int k = 0; k < channel->GetNumEvents(); k++ )
+			{
+				CChoreoEventWidget *event = channel->GetEvent( k );
+				if ( !event )
+					continue;
+
+				(this->*pfn)( event, param1 );
+			}
+		}
+	}
+
+	for ( int i = 0; i < m_SceneGlobalEvents.Size(); i++ )
+	{
+		CChoreoGlobalEventWidget *event = m_SceneGlobalEvents[ i ];
+		if ( !event )
+			continue;
+
+		(this->*pfn)( event, param1 );
+	}
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+// Input  : *widget - 
+//			*param1 - 
+//-----------------------------------------------------------------------------
+void CChoreoView::Deselect( CChoreoWidget *widget, CChoreoWidget *param1 )
+{
+	if ( widget->IsSelected() )
+	{
+		widget->SetSelected( false );
+	}
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+// Input  : *widget - 
+//			*param1 - 
+//-----------------------------------------------------------------------------
+void CChoreoView::Select( CChoreoWidget *widget, CChoreoWidget *param1 )
+{
+	if ( widget != param1 )
+		return;
+
+	if ( widget->IsSelected() )
+		return;
+
+	widget->SetSelected( true );
+}
+
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+// Input  : *widget - 
+//			*param1 - 
+//-----------------------------------------------------------------------------
+void CChoreoView::SelectAllEvents( CChoreoWidget *widget, CChoreoWidget *param1 )
+{
+	CChoreoEventWidget *ew = dynamic_cast< CChoreoEventWidget * >( widget );
+	CChoreoGlobalEventWidget *gew = dynamic_cast< CChoreoGlobalEventWidget * >( widget );
+
+	if ( ew || gew )
+	{
+		if ( widget->IsSelected() )
+			return;
+
+		widget->SetSelected( true );
+	}
+}
+
+bool CChoreoView::CreateAnimationEvent( int mx, int my, char const *animationname )
+{
+	if ( !animationname || !animationname[0] )
+		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;
+
+	pt.x -= GetLabelWidth();
+	m_nClickedX = pt.x;
+
+	GetObjectsUnderMouse( pt.x, pt.y, &m_pClickedActor, &m_pClickedChannel, &m_pClickedEvent, &m_pClickedGlobalEvent, &m_nClickedTag, &m_pClickedAbsoluteTag, &m_nClickedChannelCloseCaptionButton );
+
+	// Find channel actor and time ( uses screen space coordinates )
+	//
+	CChoreoChannelWidget *channel = GetChannelUnderCursorPos( pt.x, pt.y );
+	if ( !channel )
+	{
+		CChoreoActorWidget *actor = GetActorUnderCursorPos( pt.x, pt.y );
+		if ( !actor )
+			return false;
+
+		// Grab first channel
+		if ( !actor->GetNumChannels() )
+			return false;
+
+		channel = actor->GetChannel( 0 );
+	}
+
+	if ( !channel )
+		return false;
+
+	CChoreoChannel *pchannel = channel->GetChannel();
+	if ( !pchannel )
+	{
+		Assert( 0 );
+		return false;
+	}
+
+	// At this point we need to ask the user what type of even to create (gesture or sequence) and just show the approprite dialog
+	CChoiceParams params;
+	strcpy( params.m_szDialogTitle, "Create Animation Event" );
+
+	params.m_bPositionDialog = false;
+	params.m_nLeft = 0;
+	params.m_nTop = 0;
+	strcpy( params.m_szPrompt, "Type of event:" );
+
+	params.m_Choices.RemoveAll();
+
+	params.m_nSelected = 0;
+	ChoiceText text;
+	strcpy( text.choice, "gesture" );
+	params.m_Choices.AddToTail( text );
+	strcpy( text.choice, "sequence" );
+	params.m_Choices.AddToTail( text );
+
+	if ( !ChoiceProperties( &params ) )
+		return false;
+	
+	if ( params.m_nSelected < 0 )
+		return false;
+
+	switch ( params.m_nSelected )
+	{
+	default:
+	case 0:
+		AddEvent( CChoreoEvent::GESTURE, 0, animationname );
+		break;
+	case 1:
+		AddEvent( CChoreoEvent::SEQUENCE, 0, animationname );
+		break;
+	}
+
+	return true;
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+// Input  : mx - 
+//			my - 
+//			*cl - 
+//			*exp - 
+// Output : Returns true on success, false on failure.
+//-----------------------------------------------------------------------------
+bool CChoreoView::CreateExpressionEvent( int mx, int my, CExpClass *cl, CExpression *exp )
+{
+	if ( !m_pScene )
+		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;
+
+	// Find channel actor and time ( uses screen space coordinates )
+	//
+	CChoreoChannelWidget *channel = GetChannelUnderCursorPos( pt.x, pt.y );
+	if ( !channel )
+	{
+		CChoreoActorWidget *actor = GetActorUnderCursorPos( pt.x, pt.y );
+		if ( !actor )
+			return false;
+
+		// Grab first channel
+		if ( !actor->GetNumChannels() )
+			return false;
+
+		channel = actor->GetChannel( 0 );
+	}
+
+	if ( !channel )
+		return false;
+
+	CChoreoChannel *pchannel = channel->GetChannel();
+	if ( !pchannel )
+	{
+		Assert( 0 );
+		return false;
+	}
+
+	CChoreoEvent *event = m_pScene->AllocEvent();
+	if ( !event )
+	{
+		Assert( 0 );
+		return false;
+	}
+
+	float starttime = GetTimeValueForMouse( pt.x, false );
+
+	SetDirty( true );
+
+	PushUndo( "Create Expression" );
+
+	event->SetType( CChoreoEvent::EXPRESSION );
+	event->SetName( exp->name );
+	event->SetParameters( cl->GetName() );
+	event->SetParameters2( exp->name );
+	event->SetStartTime( starttime );
+	event->SetChannel( pchannel );
+	event->SetActor( pchannel->GetActor() );
+	event->SetEndTime( starttime + 1.0f );
+
+	event->SnapTimes();
+
+	DeleteSceneWidgets();
+
+	// Add to appropriate channel
+	pchannel->AddEvent( event );
+
+	CreateSceneWidgets();
+
+	PushRedo( "Create Expression" );
+
+	// Redraw
+	InvalidateLayout();
+
+	return true;
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+// Output : Returns true on success, false on failure.
+//-----------------------------------------------------------------------------
+bool CChoreoView::IsPlayingScene( void )
+{
+	return m_bSimulating;
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+void CChoreoView::ResetTargetSettings( void )
+{
+	for ( int i = 0; i < m_SceneActors.Size(); i++ )
+	{
+		CChoreoActorWidget *w = m_SceneActors[ i ];
+		if ( w )
+		{
+			w->ResetSettings();
+		}
+	}
+
+	models->ClearModelTargets( true );
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: copies the actors "settings" into the models FlexControllers
+// Input  : dt - 
+//-----------------------------------------------------------------------------
+void CChoreoView::UpdateCurrentSettings( void )
+{
+	StudioModel *defaultModel = models->GetActiveStudioModel();
+
+	for ( int i = 0; i < m_SceneActors.Size(); i++ )
+	{
+		CChoreoActorWidget *w = m_SceneActors[ i ];
+		if ( !w )
+			continue;
+
+		if ( !w->GetActor()->GetActive() )
+			continue;
+
+		StudioModel *model = FindAssociatedModel( m_pScene, w->GetActor() );
+		if ( !model )
+			continue;
+
+		CStudioHdr *hdr = model->GetStudioHdr();
+		if ( !hdr )
+			continue;
+
+		float *current = w->GetSettings();
+
+		for ( LocalFlexController_t j = LocalFlexController_t(0); j < hdr->numflexcontrollers(); j++ )
+		{
+			int k = hdr->pFlexcontroller( j )->localToGlobal;
+
+			if (k != -1)
+			{
+				if ( defaultModel == model && g_pFlexPanel->IsEdited( k ) )
+				{
+					model->SetFlexController( j, g_pFlexPanel->GetSlider( k ) );
+				}
+				else
+				{
+					model->SetFlexController( j, current[ k ] );
+				}
+			}
+		}
+	}
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+// Input  : *event - 
+//			tagnum - 
+//-----------------------------------------------------------------------------
+void CChoreoView::DeleteEventRelativeTag( CChoreoEvent *event, int tagnum )
+{
+	if ( !event )
+		return;
+
+	CEventRelativeTag *tag = event->GetRelativeTag( tagnum );
+	if ( !tag )
+		return;
+
+	SetDirty( true );
+
+	PushUndo( "Delete Event Tag" );
+
+	event->RemoveRelativeTag( tag->GetName() );
+
+	m_pScene->ReconcileTags();
+
+	PushRedo( "Delete Event Tag" );
+
+	g_pPhonemeEditor->redraw();
+	InvalidateLayout();
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+// Input  : *event - 
+//-----------------------------------------------------------------------------
+void CChoreoView::AddEventRelativeTag( void )
+{
+	CChoreoEventWidget *ew = m_pClickedEvent;
+	if ( !ew )
+		return;
+
+	CChoreoEvent *event = ew->GetEvent();
+	if ( !event->GetEndTime() )
+	{
+		Con_ErrorPrintf( "Event Tag:  Can only tag events with an end time\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( "Event Tag Name:  No name entered!\n" );
+		return;
+	}
+	
+	RECT bounds = ew->getBounds();
+
+	// Convert click to frac
+	float frac = 0.0f;
+	if ( bounds.right - bounds.left > 0 )
+	{
+		frac = (float)( m_nClickedX - bounds.left ) / (float)( bounds.right - bounds.left );
+		frac = min( 1.0f, frac );
+		frac = max( 0.0f, frac );
+	}
+
+	SetDirty( true );
+
+	PushUndo( "Add Event Tag" );
+
+	event->AddRelativeTag( params.m_szInputText, frac );
+
+	PushRedo( "Add Event Tag" );
+
+	InvalidateLayout();
+	g_pPhonemeEditor->redraw();
+	g_pExpressionTool->redraw();
+	g_pGestureTool->redraw();
+	g_pRampTool->redraw();
+	g_pSceneRampTool->redraw();
+}
+
+CChoreoChannelWidget *CChoreoView::FindChannelForEvent( CChoreoEvent *event )
+{
+	for ( int i = 0; i < m_SceneActors.Size(); i++ )
+	{
+		CChoreoActorWidget *a = m_SceneActors[ i ];
+		if ( !a )
+			continue;
+
+		for ( int j = 0; j < a->GetNumChannels(); j++ )
+		{
+			CChoreoChannelWidget *c = a->GetChannel( j );
+			if ( !c )
+				continue;
+
+			for ( int k = 0; k < c->GetNumEvents(); k++ )
+			{
+				CChoreoEventWidget *e = c->GetEvent( k );
+				if ( !e )
+					continue;
+
+				if ( e->GetEvent() != event )
+					continue;
+
+				return c;
+			}
+		}
+	}
+
+	return NULL;
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+// Input  : *event - 
+// Output : CChoreoEventWidget
+//-----------------------------------------------------------------------------
+CChoreoEventWidget *CChoreoView::FindWidgetForEvent( CChoreoEvent *event )
+{
+	for ( int i = 0; i < m_SceneActors.Size(); i++ )
+	{
+		CChoreoActorWidget *a = m_SceneActors[ i ];
+		if ( !a )
+			continue;
+
+		for ( int j = 0; j < a->GetNumChannels(); j++ )
+		{
+			CChoreoChannelWidget *c = a->GetChannel( j );
+			if ( !c )
+				continue;
+
+			for ( int k = 0; k < c->GetNumEvents(); k++ )
+			{
+				CChoreoEventWidget *e = c->GetEvent( k );
+				if ( !e )
+					continue;
+
+				if ( e->GetEvent() != event )
+					continue;
+
+				return e;
+			}
+		}
+	}
+
+	return NULL;
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+void CChoreoView::SelectAll( void )
+{
+	TraverseWidgets( &CChoreoView::SelectAllEvents, NULL );
+	redraw();
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+void CChoreoView::DeselectAll( void )
+{
+	TraverseWidgets( &CChoreoView::Deselect, NULL );
+	redraw();
+}
+
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+// Input  : mx - 
+//			my - 
+//-----------------------------------------------------------------------------
+void CChoreoView::UpdateStatusArea( int mx, int my )
+{
+	FLYOVER fo;
+
+	GetObjectsUnderMouse( mx, my, &fo.a, &fo.c, 
+		&fo.e, &fo.ge, &fo.tag, &fo.at, &fo.ccbutton );
+
+	if ( fo.a )
+	{
+		m_Flyover.a = fo.a;
+	}
+	if ( fo.e )
+	{
+		m_Flyover.e = fo.e;
+	}
+	if ( fo.c )
+	{
+		m_Flyover.c = fo.c;
+	}
+	if ( fo.ge )
+	{
+		m_Flyover.ge = fo.ge;
+	}
+	if ( fo.tag != -1 )
+	{
+		m_Flyover.tag = fo.tag;
+	}
+	if ( fo.ccbutton != -1 )
+	{
+		m_Flyover.ccbutton = fo.ccbutton;
+		// m_Flyover.e = NULL;
+	}
+
+	RECT rcClip;
+	GetClientRect( (HWND)getHandle(), &rcClip );
+	rcClip.bottom -= m_nScrollbarHeight;
+	rcClip.top = rcClip.bottom - m_nInfoHeight;
+	rcClip.right -= m_nScrollbarHeight;
+
+	CChoreoWidgetDrawHelper drawHelper( this, rcClip, COLOR_CHOREO_BACKGROUND );
+
+	drawHelper.StartClipping( rcClip );
+
+	RedrawStatusArea( drawHelper, rcClip );
+
+	drawHelper.StopClipping();
+	ValidateRect( (HWND)getHandle(), &rcClip );
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+void CChoreoView::ClearStatusArea( void )
+{
+	memset( &m_Flyover, 0, sizeof( m_Flyover ) );
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+// Input  : drawHelper - 
+//			rcStatus - 
+//-----------------------------------------------------------------------------
+void CChoreoView::RedrawStatusArea( CChoreoWidgetDrawHelper& drawHelper, RECT& rcStatus )
+{
+	drawHelper.DrawFilledRect( COLOR_CHOREO_BACKGROUND, rcStatus );
+
+	drawHelper.DrawColoredLine( COLOR_INFO_BORDER, PS_SOLID, 1, rcStatus.left, rcStatus.top,
+		rcStatus.right, rcStatus.top );
+
+	RECT rcInfo = rcStatus;
+
+	rcInfo.top += 2;
+
+	if ( m_Flyover.e )
+	{
+		m_Flyover.e->redrawStatus( drawHelper, rcInfo );
+	}
+	if ( m_Flyover.c &&
+		m_Flyover.ccbutton != -1 )
+	{
+		m_Flyover.c->redrawStatus( drawHelper, rcInfo, m_Flyover.ccbutton );
+	}
+
+	if ( m_pScene )
+	{
+		char sz[ 512 ];
+
+		int fontsize = 9;
+		int fontweight = FW_NORMAL;
+
+		RECT rcText;
+		rcText = rcInfo;
+		rcText.bottom = rcText.top + fontsize + 2;
+
+		char const *mapname = m_pScene->GetMapname();
+		if ( mapname )
+		{
+			sprintf( sz, "Associated .bsp:  %s", mapname[ 0 ] ? mapname : "none" );
+
+			int len = drawHelper.CalcTextWidth( "Arial", fontsize, fontweight, sz );
+			rcText.left = rcText.right - len - 10;
+
+			drawHelper.DrawColoredText( "Arial", fontsize, fontweight, COLOR_INFO_TEXT, rcText, sz );
+
+			OffsetRect( &rcText, 0, fontsize + 2 );
+		}
+
+		sprintf( sz, "Scene:  %s", GetChoreoFile() );
+
+		int len = drawHelper.CalcTextWidth( "Arial", fontsize, fontweight, sz );
+		rcText.left = rcText.right - len - 10;
+
+		drawHelper.DrawColoredText( "Arial", fontsize, fontweight, COLOR_INFO_TEXT, rcText, sz );
+	}
+
+//	drawHelper.DrawColoredText( "Arial", 12, 500, RGB( 0, 0, 0 ), rcInfo, m_Flyover.e ? m_Flyover.e->GetEvent()->GetName() : "" );
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+// Input  : *event - 
+//-----------------------------------------------------------------------------
+void CChoreoView::MoveEventToBack( CChoreoEvent *event )
+{
+	// Now find channel widget
+	for ( int i = 0; i < m_SceneActors.Size(); i++ )
+	{
+		CChoreoActorWidget *a = m_SceneActors[ i ];
+		if ( !a )
+			continue;
+
+		for ( int j = 0; j < a->GetNumChannels(); j++ )
+		{
+			CChoreoChannelWidget *c = a->GetChannel( j );
+			if ( !c )
+				continue;
+
+			for ( int k = 0; k < c->GetNumEvents(); k++ )
+			{
+				CChoreoEventWidget *e = c->GetEvent( k );
+				if ( !e )
+					continue;
+
+				if ( event == e->GetEvent() )
+				{
+					// Move it to back of channel's list
+					c->MoveEventToTail( e );
+					InvalidateLayout();
+					return;
+				}
+			}
+		}
+	}
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+// Output : int
+//-----------------------------------------------------------------------------
+int CChoreoView::GetEndRow( void )
+{
+	RECT rcClient;
+	GetClientRect( (HWND)getHandle(), &rcClient );
+
+	return rcClient.bottom - ( m_nInfoHeight + m_nScrollbarHeight );
+}
+
+// Undo/Redo
+void CChoreoView::Undo( void )
+{
+	if ( m_UndoStack.Size() > 0 && m_nUndoLevel > 0 )
+	{
+		m_nUndoLevel--;
+		CVUndo *u = m_UndoStack[ m_nUndoLevel ];
+		Assert( u->undo );
+
+		DeleteSceneWidgets();
+
+		*m_pScene = *(u->undo);
+		g_MDLViewer->InitGridSettings();
+
+		CreateSceneWidgets();
+
+		ReportSceneClearToTools();
+		ClearStatusArea();
+		m_pClickedActor = NULL;
+		m_pClickedChannel = NULL;
+		m_pClickedEvent = NULL;
+		m_pClickedGlobalEvent = NULL; 
+	}
+
+	InvalidateLayout();
+}
+
+void CChoreoView::Redo( void )
+{
+	if ( m_UndoStack.Size() > 0 && m_nUndoLevel <= m_UndoStack.Size() - 1 )
+	{
+		CVUndo *u = m_UndoStack[ m_nUndoLevel ];
+		Assert( u->redo );
+
+		DeleteSceneWidgets();
+
+		*m_pScene = *(u->redo);
+		g_MDLViewer->InitGridSettings();
+
+		CreateSceneWidgets();
+
+		ReportSceneClearToTools();
+		ClearStatusArea();
+		m_pClickedActor = NULL;
+		m_pClickedChannel = NULL;
+		m_pClickedEvent = NULL;
+		m_pClickedGlobalEvent = NULL; 
+
+		m_nUndoLevel++;
+	}
+
+	InvalidateLayout();
+}
+
+static char *CopyString( const char *in )
+{
+	int len = strlen( in );
+	char *n = new char[ len + 1 ];
+	strcpy( n, in );
+	return n;
+}
+
+void CChoreoView::PushUndo( const char *description )
+{
+	Assert( !m_bRedoPending );
+	m_bRedoPending = true;
+	WipeRedo();
+
+	// Copy current data
+	CChoreoScene *u = new CChoreoScene( this );
+	*u = *m_pScene;
+	CVUndo *undo = new CVUndo;
+	undo->undo = u;
+	undo->redo = NULL;
+	undo->udescription = CopyString( description );
+	undo->rdescription = NULL;
+	m_UndoStack.AddToTail( undo );
+	m_nUndoLevel++;
+}
+
+void CChoreoView::PushRedo( const char *description )
+{
+	Assert( m_bRedoPending );
+	m_bRedoPending = false;
+
+	// Copy current data
+	CChoreoScene *r = new CChoreoScene( this );
+	*r = *m_pScene;
+	CVUndo *undo = m_UndoStack[ m_nUndoLevel - 1 ];
+	undo->redo = r;
+	undo->rdescription = CopyString( description );
+
+	// Always redo here to reflect that someone has made a change
+	redraw();
+}
+
+void CChoreoView::WipeUndo( void )
+{
+	while ( m_UndoStack.Size() > 0 )
+	{
+		CVUndo *u = m_UndoStack[ 0 ];
+		delete u->undo;
+		delete u->redo;
+		delete[] u->udescription;
+		delete[] u->rdescription;
+		delete u;
+		m_UndoStack.Remove( 0 );
+	}
+	m_nUndoLevel = 0;
+}
+
+void CChoreoView::WipeRedo( void )
+{
+	// Wipe everything above level
+	while ( m_UndoStack.Size() > m_nUndoLevel )
+	{
+		CVUndo *u = m_UndoStack[ m_nUndoLevel ];
+		delete u->undo;
+		delete u->redo;
+		delete[] u->udescription;
+		delete[] u->rdescription;
+		delete u;
+		m_UndoStack.Remove( m_nUndoLevel );
+	}
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+// Output : const char
+//-----------------------------------------------------------------------------
+const char *CChoreoView::GetUndoDescription( void )
+{
+	if ( CanUndo() )
+	{
+		CVUndo *u = m_UndoStack[ m_nUndoLevel - 1 ];
+		return u->udescription;
+	}
+	return "???undo";
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+// Output : const char
+//-----------------------------------------------------------------------------
+const char *CChoreoView::GetRedoDescription( void )
+{
+	if ( CanRedo() )
+	{
+		CVUndo *u = m_UndoStack[ m_nUndoLevel ];
+		return u->rdescription;
+	}
+	return "???redo";
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+// Output : Returns true on success, false on failure.
+//-----------------------------------------------------------------------------
+bool CChoreoView::CanUndo()
+{
+	return m_nUndoLevel != 0;
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+// Output : Returns true on success, false on failure.
+//-----------------------------------------------------------------------------
+bool CChoreoView::CanRedo()
+{
+	return m_nUndoLevel != m_UndoStack.Size();
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+void CChoreoView::OnGestureTool( void )
+{
+	if ( m_pClickedEvent->GetEvent()->GetType() != CChoreoEvent::GESTURE )
+		return;
+
+	g_pGestureTool->SetEvent( m_pClickedEvent->GetEvent() );
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+void CChoreoView::OnExpressionTool( void )
+{
+	if ( m_pClickedEvent->GetEvent()->GetType() != CChoreoEvent::FLEXANIMATION )
+		return;
+
+	g_pExpressionTool->SetEvent( m_pClickedEvent->GetEvent() );
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+// Output : CChoreoScene
+//-----------------------------------------------------------------------------
+CChoreoScene *CChoreoView::GetScene( void )
+{
+	return m_pScene;
+}
+
+bool CChoreoView::CanPaste( void )
+{
+	char const *copyfile = COPYPASTE_FILENAME;
+
+	if ( !filesystem->FileExists( copyfile ) )
+	{
+		return false;
+	}
+
+	return true;
+}
+
+void CChoreoView::CopyEvents( void )
+{
+	if ( !m_pScene )
+		return;
+
+	char const *copyfile = COPYPASTE_FILENAME;
+	MakeFileWriteable( copyfile );
+	ExportVCDFile( copyfile );
+}
+
+void CChoreoView::PasteEvents( void )
+{
+	if ( !m_pScene )
+		return;
+
+	if ( !CanPaste() )
+		return;
+
+	char const *copyfile = COPYPASTE_FILENAME;
+
+	ImportVCDFile( copyfile );
+}
+
+void CChoreoView::ImportEvents( void )
+{
+	if ( !m_pScene )
+		return;
+
+	if ( !m_pClickedActor || !m_pClickedChannel )
+		return;
+
+	char eventfile[ 512 ];
+	if ( !FacePoser_ShowOpenFileNameDialog( eventfile, sizeof( eventfile ), "scenes", "*.vce" ) )
+		return;
+	
+	char fullpathbuf[ 512 ];
+	char *fullpath = eventfile;
+	if ( !Q_IsAbsolutePath( eventfile ) )
+	{
+		filesystem->RelativePathToFullPath( eventfile, "GAME", fullpathbuf, sizeof( fullpathbuf ) );
+		fullpath = fullpathbuf;
+	}
+
+	if ( !filesystem->FileExists( fullpath ) )
+		return;
+
+	LoadScriptFile( fullpath );
+
+	DeselectAll();
+
+	SetDirty( true );
+
+	PushUndo( "Import Events" );
+
+	m_pScene->ImportEvents( tokenprocessor, m_pClickedActor->GetActor(), m_pClickedChannel->GetChannel() );
+
+	PushRedo( "Import Events" );
+
+	CreateSceneWidgets();
+	// Redraw
+	InvalidateLayout();
+
+	Con_Printf( "Imported events from %s\n", fullpath );
+}
+
+void CChoreoView::ExportEvents( void )
+{
+	char eventfilename[ 512 ];
+	if ( !FacePoser_ShowSaveFileNameDialog( eventfilename, sizeof( eventfilename ), "scenes", "*.vce" ) )
+		return;
+
+	Q_DefaultExtension( eventfilename, ".vce", sizeof( eventfilename ) );
+
+	Con_Printf( "Exporting events to %s\n", eventfilename );
+
+	// Write to file
+	CUtlVector< CChoreoEvent * > events;
+
+	// Find selected eventss
+	for ( int i = 0; i < m_SceneActors.Size(); i++ )
+	{
+		CChoreoActorWidget *a = m_SceneActors[ i ];
+		if ( !a )
+			continue;
+
+		for ( int j = 0; j < a->GetNumChannels(); j++ )
+		{
+			CChoreoChannelWidget *c = a->GetChannel( j );
+			if ( !c )
+				continue;
+
+			for ( int k = 0; k < c->GetNumEvents(); k++ )
+			{
+				CChoreoEventWidget *e = c->GetEvent( k );
+				if ( !e )
+					continue;
+
+				if ( !e->IsSelected() )
+					continue;
+
+				CChoreoEvent *event = e->GetEvent();
+				if ( !event )
+					continue;
+
+				events.AddToTail( event );
+			}
+		}
+	}
+
+	if ( events.Size() > 0 )
+	{
+		m_pScene->ExportEvents( eventfilename, events );
+	}
+	else
+	{
+		Con_Printf( "No events selected\n" );
+	}
+}
+
+void CChoreoView::ExportVCDFile( char const *filename )
+{
+	Con_Printf( "Exporting to %s\n", filename );
+
+	// Unmark everything
+	m_pScene->MarkForSaveAll( false );
+
+	// Mark everything related to selected events
+	for ( int i = 0; i < m_SceneActors.Size(); i++ )
+	{
+		CChoreoActorWidget *a = m_SceneActors[ i ];
+		if ( !a )
+			continue;
+
+		for ( int j = 0; j < a->GetNumChannels(); j++ )
+		{
+			CChoreoChannelWidget *c = a->GetChannel( j );
+			if ( !c )
+				continue;
+
+			for ( int k = 0; k < c->GetNumEvents(); k++ )
+			{
+				CChoreoEventWidget *e = c->GetEvent( k );
+				if ( !e )
+					continue;
+
+				if ( !e->IsSelected() )
+					continue;
+
+				CChoreoEvent *event = e->GetEvent();
+				if ( !event )
+					continue;
+
+				event->SetMarkedForSave( true );
+				if ( event->GetChannel() )
+				{
+					event->GetChannel()->SetMarkedForSave( true );
+				}
+				if ( event->GetActor() )
+				{
+					event->GetActor()->SetMarkedForSave( true );
+				}
+			}
+		}
+	}
+
+	m_pScene->ExportMarkedToFile( filename );
+}
+
+void CChoreoView::ImportVCDFile( char const *filename )
+{
+	CChoreoScene *merge = LoadScene( filename );
+	if ( !merge )
+	{
+		Con_Printf( "Couldn't load from .vcd %s\n", filename );
+		return;
+	}
+
+	DeselectAll();
+
+	CUtlRBTree< CChoreoEvent *, int > oldEvents( 0, 0, DefLessFunc( CChoreoEvent * ) );
+
+	int i;
+	for ( i = 0; i < m_SceneActors.Count(); ++i )
+	{
+		CChoreoActorWidget *actor = m_SceneActors[ i ];
+		if ( !actor )
+			continue;
+
+		for ( int j = 0; j < actor->GetNumChannels(); j++ )
+		{
+			CChoreoChannelWidget *channel = actor->GetChannel( j );
+			if ( !channel )
+				continue;
+
+			for ( int k = 0; k < channel->GetNumEvents(); k++ )
+			{
+				CChoreoEventWidget *event = channel->GetEvent( k );
+				if ( !event )
+					continue;
+
+				oldEvents.Insert( event->GetEvent() );
+			}
+		}
+	}
+
+	SetDirty( true );
+
+	PushUndo( "Merge/Import VCD" );
+
+	m_pScene->Merge( merge );
+
+	PushRedo( "Merge/Import VCD" );
+
+	DeleteSceneWidgets();
+	CreateSceneWidgets();
+
+	// Force scroll bars to recompute
+	ForceScrollBarsToRecompute( false );
+
+	// Now walk through the "new" events and select everything that wasn't already there (all of the stuff that was "added" during the merge)
+	for ( i = 0; i < m_SceneActors.Count(); ++i )
+	{
+		CChoreoActorWidget *actor = m_SceneActors[ i ];
+		if ( !actor )
+			continue;
+
+		for ( int j = 0; j < actor->GetNumChannels(); j++ )
+		{
+			CChoreoChannelWidget *channel = actor->GetChannel( j );
+			if ( !channel )
+				continue;
+
+			for ( int k = 0; k < channel->GetNumEvents(); k++ )
+			{
+				CChoreoEventWidget *event = channel->GetEvent( k );
+				if ( !event )
+					continue;
+
+				if ( oldEvents.Find( event->GetEvent() ) == oldEvents.InvalidIndex() )
+				{
+					event->SetSelected( true );
+				}
+			}
+		}
+	}
+
+	// Redraw
+	InvalidateLayout();
+
+	Con_Printf( "Imported vcd '%s'\n", filename );
+
+	delete merge;
+
+	redraw();
+}
+
+void CChoreoView::ExportVCD()
+{
+	char scenefile[ 512 ];
+	if ( !FacePoser_ShowSaveFileNameDialog( scenefile, sizeof( scenefile ), "scenes", "*.vcd" ) )
+	{
+		return;
+	}
+
+	Q_DefaultExtension( scenefile, ".vcd", sizeof( scenefile ) );
+
+	ExportVCDFile( scenefile );
+}
+
+void CChoreoView::ImportVCD()
+{
+	if ( !m_pScene )
+		return;
+
+	if ( !m_pClickedActor || !m_pClickedChannel )
+		return;
+
+	char scenefile[ 512 ];
+	if ( !FacePoser_ShowOpenFileNameDialog( scenefile, sizeof( scenefile ), "scenes", "*.vcd" ) )
+	{
+		return;
+	}
+
+	ImportVCDFile( scenefile );
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+// Output : Returns true on success, false on failure.
+//-----------------------------------------------------------------------------
+bool CChoreoView::IsProcessing( void )
+{
+	if ( !m_pScene )
+		return false;
+
+	if ( m_flScrub != m_flScrubTarget )
+		return true;
+
+	return false;
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+// Output : Returns true on success, false on failure.
+//-----------------------------------------------------------------------------
+bool CChoreoView::ShouldProcessSpeak( void )
+{
+	if ( !g_pControlPanel->AllToolsDriveSpeech() )
+	{
+		if ( !IsActiveTool() )
+			return false;
+	}
+
+	if ( IFacePoserToolWindow::IsAnyToolScrubbing() )
+		return true;
+
+	if ( IFacePoserToolWindow::IsAnyToolProcessing() )
+		return true;
+
+	return false;
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+// Input  : *scene - 
+//			*event - 
+//-----------------------------------------------------------------------------
+void CChoreoView::ProcessSpeak( CChoreoScene *scene, CChoreoEvent *event )
+{
+	if ( !ShouldProcessSpeak() )
+		return;
+
+	Assert( event->GetType() == CChoreoEvent::SPEAK );
+	Assert( scene );
+
+	float t = scene->GetTime();
+
+	StudioModel *model = FindAssociatedModel( scene, event->GetActor() );
+
+	// See if we should trigger CC
+	char soundname[ 512 ];
+	Q_strncpy( soundname, event->GetParameters(), sizeof( soundname ) );
+
+	float actualEndTime = event->GetEndTime();
+
+	if ( event->GetCloseCaptionType() == CChoreoEvent::CC_MASTER )
+	{
+		char tok[ CChoreoEvent::MAX_CCTOKEN_STRING ];
+		if ( event->GetPlaybackCloseCaptionToken( tok, sizeof( tok ) ) )
+		{
+			// Use the token as the sound name lookup, too.
+			if ( event->IsUsingCombinedFile() &&
+				 ( event->GetNumSlaves() > 0 ) ) 
+			{
+				Q_strncpy( soundname, tok, sizeof( soundname ) );
+				actualEndTime = max( actualEndTime, event->GetLastSlaveEndTime() );
+			}
+		}
+	}
+
+	CAudioMixer *mixer = event->GetMixer();
+	if ( !mixer || !sound->IsSoundPlaying( mixer ) )
+	{
+		CSoundParameters params;
+		float volume = VOL_NORM;
+		
+		gender_t gender = GENDER_NONE;
+		if (model)
+		{
+			gender = soundemitter->GetActorGender( model->GetFileName() );
+		}
+
+		if ( !Q_stristr( soundname, ".wav" ) &&
+			soundemitter->GetParametersForSound( soundname, params, gender ) )
+		{
+			volume = params.volume;
+		}
+
+		sound->PlaySound( 
+			model, 
+			volume,
+			va( "sound/%s", FacePoser_TranslateSoundName( soundname, model ) ), 
+			&mixer );
+		event->SetMixer( mixer );
+	}
+
+	mixer = event->GetMixer();
+	if ( !mixer )
+		return;
+
+	mixer->SetDirection( m_flFrameTime >= 0.0f );
+	float starttime, endtime;
+	starttime = event->GetStartTime();
+	endtime = actualEndTime;
+
+	float soundtime = endtime - starttime;
+	if ( soundtime <= 0.0f )
+		return;
+
+	float f = ( t - starttime ) / soundtime;
+	f = clamp( f, 0.0f, 1.0f );
+
+	// Compute sample
+	float numsamples = (float)mixer->GetSource()->SampleCount();
+
+	int cursample = f * numsamples;
+	cursample = clamp( cursample, 0, numsamples - 1 );
+
+	int realsample = mixer->GetSamplePosition();
+
+	int dsample = cursample - realsample;
+
+	int samplelimit = mixer->GetSource()->SampleRate() * 0.02f; // don't shift until samples are off by this much
+	if (IsScrubbing())
+	{
+		samplelimit = mixer->GetSource()->SampleRate() * 0.01f; // make it shorter tolerance when scrubbing
+	}
+
+	if ( abs( dsample ) > samplelimit )
+	{
+		mixer->SetSamplePosition( cursample, IsScrubbing() );
+	}
+	mixer->SetActive( true );
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+// Input  : *event - 
+// Output : Returns true on success, false on failure.
+//-----------------------------------------------------------------------------
+void CChoreoView::ProcessSubscene( CChoreoScene *scene, CChoreoEvent *event )
+{
+	Assert( event->GetType() == CChoreoEvent::SUBSCENE );
+
+	CChoreoScene *subscene = event->GetSubScene();
+	if ( !subscene )
+		return;
+
+	if ( subscene->SimulationFinished() )
+		return;
+	
+	// Have subscenes think for appropriate time
+	subscene->Think( m_flScrub );
+}
+
+void CChoreoView::PositionControls()
+{
+	int topx = GetCaptionHeight() + SCRUBBER_HEIGHT;
+
+	int bx = 2;
+	int bw = 16;
+
+	m_btnPlay->setBounds( bx, topx + 4, 16, 16 );
+
+	bx += bw + 2;
+
+	m_btnPause->setBounds( bx, topx + 4, 16, 16 );
+	bx += bw + 2;
+	m_btnStop->setBounds( bx, topx + 4, 16, 16 );
+	bx += bw + 2;
+	m_pPlaybackRate->setBounds( bx, topx + 4, 100, 16 );
+}
+
+void CChoreoView::SetChoreoFile( char const *filename )
+{
+	strcpy( m_szChoreoFile, filename );
+	if ( m_szChoreoFile[ 0 ] )
+	{
+		char sz[ 256 ];
+		if ( IsFileWriteable( m_szChoreoFile ) )
+		{
+			Q_snprintf( sz, sizeof( sz ), " - %s", m_szChoreoFile );
+		}
+		else
+		{
+			Q_snprintf( sz, sizeof( sz ), " - %s [Read-Only]", m_szChoreoFile );
+		}
+		SetSuffix( sz );
+	}
+	else
+	{
+		SetSuffix( "" );
+	}
+}
+
+char const *CChoreoView::GetChoreoFile( void ) const
+{
+	return m_szChoreoFile;
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+// Input  : rcHandle - 
+//-----------------------------------------------------------------------------
+void CChoreoView::GetScrubHandleRect( RECT& rcHandle, bool clipped )
+{
+	float pixel = 0.0f;
+
+	if ( m_pScene )
+	{
+		float currenttime = m_flScrub;
+		float starttime = m_flStartTime;
+		float endtime = m_flEndTime;
+
+		float screenfrac = ( currenttime - starttime ) / ( endtime - starttime );
+
+		pixel = GetLabelWidth() + screenfrac * ( w2() - GetLabelWidth() );
+
+		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  : rcArea - 
+//-----------------------------------------------------------------------------
+void CChoreoView::GetScrubAreaRect( RECT& rcArea )
+{
+	rcArea.left = 0;
+	rcArea.right = w2();
+	rcArea.top = 2 + GetCaptionHeight();
+	rcArea.bottom = rcArea.top + SCRUBBER_HEIGHT - 4;
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+// Input  : drawHelper - 
+//			rcHandle - 
+//-----------------------------------------------------------------------------
+void CChoreoView::DrawScrubHandle( CChoreoWidgetDrawHelper& drawHelper )
+{
+	RECT rcHandle;
+	GetScrubHandleRect( rcHandle, true );
+
+	HBRUSH br = CreateSolidBrush( RGB( 0, 150, 100 ) );
+
+	drawHelper.DrawFilledRect( br, rcHandle );
+
+	// 
+	char sz[ 32 ];
+	sprintf( sz, "%.3f", 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 CChoreoView::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;
+}
+
+bool CChoreoView::IsMouseOverScrubArea( mxEvent *event )
+{
+	RECT rcArea;
+	GetScrubAreaRect( rcArea );
+
+	InflateRect( &rcArea, 2, 2 );
+
+	POINT pt;
+	pt.x = (short)event->x;
+	pt.y = (short)event->y;
+	if ( PtInRect( &rcArea, pt ) )
+	{
+		return true;
+	}
+
+	return false;
+}
+
+bool CChoreoView::IsScrubbing( void ) const
+{
+	bool scrubbing = ( m_nDragType == DRAGTYPE_SCRUBBER ) ? true : false;
+	return scrubbing;
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+// Input  : dt - 
+//-----------------------------------------------------------------------------
+void CChoreoView::Think( float dt )
+{
+	bool scrubbing = IFacePoserToolWindow::IsAnyToolScrubbing();
+
+	ScrubThink( dt, scrubbing, this );
+}
+
+static int lastthinkframe = -1;
+void CChoreoView::ScrubThink( float dt, bool scrubbing, IFacePoserToolWindow *invoker )
+{
+	// Make sure we don't get called more than once per frame
+	int thisframe = g_MDLViewer->GetCurrentFrame();
+	if ( thisframe == lastthinkframe )
+		return;
+
+	lastthinkframe = thisframe;
+
+	if ( !m_pScene )
+		return;
+
+	if ( m_flScrubTarget == m_flScrub && !scrubbing )
+	{
+		// Act like it's paused
+		if ( IFacePoserToolWindow::ShouldAutoProcess() )
+		{
+			m_bSimulating = true;
+			SceneThink( m_flScrub );
+		}
+
+		if ( m_bSimulating && !m_bPaused )
+		{
+			//FinishSimulation();
+		}
+		return;
+	}
+
+	// Make sure we're solving head turns during playback
+	models->SetSolveHeadTurn( 1 );
+
+	if ( m_bPaused )
+	{
+		SceneThink( m_flScrub );
+		return;
+	}
+
+	// Make sure phonemes are loaded
+	FacePoser_EnsurePhonemesLoaded();
+
+	if ( !m_bSimulating )
+	{
+		m_bSimulating = true;
+	}
+
+	float d = m_flScrubTarget - m_flScrub;
+	int sign = d > 0.0f ? 1 : -1;
+
+	float maxmove = dt * m_flPlaybackRate;
+
+	float prevScrub = m_flScrub;
+
+	if ( sign > 0 )
+	{
+		if ( d < maxmove )
+		{
+			m_flScrub = m_flScrubTarget;
+		}
+		else
+		{
+			m_flScrub += maxmove;
+		}
+	}
+	else
+	{
+		if ( -d < maxmove )
+		{
+			m_flScrub = m_flScrubTarget;
+		}
+		else
+		{
+			m_flScrub -= maxmove;
+		}
+	}
+
+	m_flFrameTime = ( m_flScrub - prevScrub );
+
+	SceneThink( m_flScrub );
+
+	DrawScrubHandle();
+
+	if ( scrubbing )
+	{
+		g_pMatSysWindow->Frame();
+	}
+
+	if ( invoker != g_pExpressionTool )
+	{
+		g_pExpressionTool->ForceScrubPositionFromSceneTime( m_flScrub );
+	}
+	if ( invoker != g_pGestureTool )
+	{
+		g_pGestureTool->ForceScrubPositionFromSceneTime( m_flScrub );
+	}
+	if ( invoker != g_pRampTool )
+	{
+		g_pRampTool->ForceScrubPositionFromSceneTime( m_flScrub );
+	}
+	if ( invoker != g_pSceneRampTool )
+	{
+		g_pSceneRampTool->ForceScrubPositionFromSceneTime( m_flScrub );
+	}
+}
+
+void CChoreoView::DrawScrubHandle( void )
+{
+	if ( !m_bCanDraw )
+		return;
+
+	// Handle new time and
+	RECT rcArea;
+	GetScrubAreaRect( rcArea );
+
+	CChoreoWidgetDrawHelper drawHelper( this, rcArea, COLOR_CHOREO_BACKGROUND );
+	DrawScrubHandle( drawHelper );
+}
+
+void CChoreoView::SetScrubTime( float t )
+{
+	m_flScrub = t;
+
+	m_bPaused = false;
+}
+
+void CChoreoView::SetScrubTargetTime( float t )
+{
+	m_flScrubTarget = t;
+
+	m_bPaused = false;
+}
+
+void CChoreoView::ClampTimeToSelectionInterval( float& timeval )
+{
+	// FIXME hook this up later
+	return;
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+// Input  : show - 
+//-----------------------------------------------------------------------------
+void CChoreoView::ShowButtons( bool show )
+{
+	m_btnPlay->setVisible( show );
+	m_btnPause->setVisible( show );
+	m_btnStop->setVisible( show );
+	m_pPlaybackRate->setVisible( show );
+}
+	
+void CChoreoView::RememberSelectedEvents( CUtlVector< CChoreoEvent * >& list )
+{
+	GetSelectedEvents( list );
+}
+
+void CChoreoView::ReselectEvents( CUtlVector< CChoreoEvent * >& list )
+{
+	for ( int i = 0; i < m_SceneActors.Size(); i++ )
+	{
+		CChoreoActorWidget *actor = m_SceneActors[ i ];
+		if ( !actor )
+			continue;
+
+		for ( int j = 0; j < actor->GetNumChannels(); j++ )
+		{
+			CChoreoChannelWidget *channel = actor->GetChannel( j );
+			if ( !channel )
+				continue;
+
+			for ( int k = 0; k < channel->GetNumEvents(); k++ )
+			{
+				CChoreoEventWidget *event = channel->GetEvent( k );
+				if ( !event )
+					continue;
+
+				CChoreoEvent *check = event->GetEvent();
+				if ( list.Find( check ) != list.InvalidIndex() )
+				{
+					event->SetSelected( true );
+				}
+			}
+		}
+	}
+
+}
+
+void CChoreoView::OnChangeScale( void )
+{
+	CChoreoScene *scene = m_pScene;
+	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)GetTimeZoom( GetToolName() ) / 100.0f );
+
+	if ( !InputProperties( &params ) )
+		return;
+
+	SetTimeZoom( GetToolName(), clamp( (int)( 100.0f * atof( params.m_szInputText ) ), 1, MAX_TIME_ZOOM ), false );
+
+	// Force scroll bars to recompute
+	ForceScrollBarsToRecompute( false );
+
+	CUtlVector< CChoreoEvent * > selected;
+	RememberSelectedEvents( selected );
+
+	DeleteSceneWidgets();
+	CreateSceneWidgets();
+
+	ReselectEvents( selected );
+
+	InvalidateLayout();
+	Con_Printf( "Zoom factor %i %%\n", GetTimeZoom( GetToolName() ) );
+}
+
+void CChoreoView::OnCheckSequenceLengths( void )
+{
+	if ( !m_pScene )
+		return;
+
+	Con_Printf( "Checking sequence durations...\n" );
+
+	bool changed = FixupSequenceDurations( m_pScene, true );
+
+	if ( !changed )
+	{
+		Con_Printf( "   no changes...\n" );
+		return;
+	}
+
+	SetDirty( true );
+
+	PushUndo( "Check sequence lengths" );
+
+	FixupSequenceDurations( m_pScene, false );
+
+	PushRedo( "Check sequence lengths" );
+
+	InvalidateLayout();
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+// Input  : *scene - 
+//-----------------------------------------------------------------------------
+void CChoreoView::InvalidateTrackLookup_R( CChoreoScene *scene )
+{
+	// No need to undo since this data doesn't matter
+	int c = scene->GetNumEvents();
+	for ( int i = 0; i < c; i++ )
+	{
+		CChoreoEvent *event = scene->GetEvent( i );
+		if ( !event )
+			continue;
+
+		switch ( event->GetType() )
+		{
+		default:
+			break;
+		case CChoreoEvent::FLEXANIMATION:
+			{
+				event->SetTrackLookupSet( false );
+			}
+			break;
+		case CChoreoEvent::SUBSCENE:
+			{
+				CChoreoScene *sub = event->GetSubScene();
+				// NOTE:  Don't bother loading it now if it's not on hand
+				if ( sub )
+				{
+					InvalidateTrackLookup_R( sub );
+				}
+			}
+			break;
+		}
+	}
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: Model changed so we'll have to re-index flex anim tracks
+//-----------------------------------------------------------------------------
+void CChoreoView::InvalidateTrackLookup( void )
+{
+	if ( !m_pScene )
+		return;
+
+	InvalidateTrackLookup_R( m_pScene );
+}
+
+
+
+bool CChoreoView::IsRampOnly( void ) const
+{
+	return m_bRampOnly;
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+// Input  : *scene - 
+//			*event - 
+//-----------------------------------------------------------------------------
+void CChoreoView::ProcessInterrupt( CChoreoScene *scene, CChoreoEvent *event )
+{
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+// Input  : *scene - 
+//			*event - 
+//-----------------------------------------------------------------------------
+void CChoreoView::ProcessPermitResponses( CChoreoScene *scene, CChoreoEvent *event )
+{
+}
+
+void CChoreoView::ApplyBounds( int& mx, int& my )
+{
+	if ( !m_bUseBounds )
+		return;
+
+	mx = clamp( mx, m_nMinX, m_nMaxX );
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: Returns -1 if no event found
+// Input  : *channel - 
+//			*e - 
+//			forward - 
+// Output : float
+//-----------------------------------------------------------------------------
+float CChoreoView::FindNextEventTime( CChoreoEvent::EVENTTYPE type, CChoreoChannel *channel, CChoreoEvent *e, bool forward )
+{
+	bool foundone = false;
+	float bestTime = -1.0f;
+	float bestGap = 999999.0f;
+
+	int c = channel->GetNumEvents();
+	for ( int i = 0; i < c; i++ )
+	{
+		CChoreoEvent *test = channel->GetEvent( i );
+		if ( test->GetType() != type )
+			continue;
+
+		if ( forward )
+		{
+			float dt = test->GetStartTime() - e->GetEndTime();
+			if ( dt <= 0.0f )
+				continue;
+
+			if ( dt < bestGap )
+			{
+				foundone = true;
+				bestGap = dt;
+				bestTime = test->GetStartTime();
+			}
+		}
+		else
+		{
+			float dt = e->GetStartTime() - test->GetEndTime();
+			if ( dt <= 0.0f )
+				continue;
+
+			if ( dt < bestGap )
+			{
+				foundone = true;
+				bestGap = dt;
+				bestTime = test->GetEndTime();
+			}
+		}
+	}
+
+	return bestTime;
+}
+
+void CChoreoView::CalcBounds( int movetype )
+{
+	m_bUseBounds = false;
+	m_nMinX = 0;
+	m_nMaxX = 0;
+
+	if ( !m_pClickedEvent )
+		return;
+
+	switch ( movetype )
+	{
+	default:
+		break;
+	case DRAGTYPE_EVENT_MOVE:
+	case DRAGTYPE_EVENT_STARTTIME:
+	case DRAGTYPE_EVENT_ENDTIME:
+	case DRAGTYPE_EVENT_STARTTIME_RESCALE:
+	case DRAGTYPE_EVENT_ENDTIME_RESCALE:
+		{
+			m_nMinX = GetPixelForTimeValue( 0 );
+			m_nMaxX = GetPixelForTimeValue( m_pScene->FindStopTime() );
+
+			CChoreoEvent *e = m_pClickedEvent->GetEvent();
+
+			m_bUseBounds = false; // e && e->GetType() == CChoreoEvent::GESTURE;
+			// FIXME: use this for finding adjacent gesture edges (kenb)
+			if ( m_bUseBounds )
+			{
+				CChoreoChannel *channel = e->GetChannel();
+				Assert( channel );
+
+				float forwardTime = FindNextEventTime( e->GetType(), channel, e, true );
+				float reverseTime = FindNextEventTime( e->GetType(), channel, e, false );
+
+				// Compute pixel for time
+				int nextPixel = forwardTime != -1 ? GetPixelForTimeValue( forwardTime ) : m_nMaxX;
+				int prevPixel = reverseTime != -1 ? GetPixelForTimeValue( reverseTime ) : m_nMinX;
+
+				int startPixel = GetPixelForTimeValue( e->GetStartTime() );
+				int endPixel = GetPixelForTimeValue( e->GetEndTime() );
+
+				switch ( movetype )
+				{
+				case DRAGTYPE_EVENT_MOVE:
+					{
+						m_nMinX = prevPixel + ( m_xStart - startPixel ) + 1;
+						m_nMaxX = nextPixel - ( endPixel - m_xStart ) - 1;
+					}
+					break;
+				case DRAGTYPE_EVENT_STARTTIME:
+				case DRAGTYPE_EVENT_STARTTIME_RESCALE:
+					{
+						m_nMinX = prevPixel + ( m_xStart - startPixel ) + 1;
+					}
+					break;
+				case DRAGTYPE_EVENT_ENDTIME:
+				case DRAGTYPE_EVENT_ENDTIME_RESCALE:
+					{
+						m_nMaxX = nextPixel - ( endPixel - m_xStart ) - 1;
+					}
+					break;
+				}
+			}
+		}
+		break;
+	}
+}
+
+bool CChoreoView::ShouldSelectEvent( SelectionParams_t &params, CChoreoEvent *event )
+{
+	if ( params.forward )
+	{
+		if ( event->GetStartTime() >= params.time )
+			return true;
+	}
+	else
+	{
+		float endtime = event->HasEndTime() ? event->GetEndTime() : event->GetStartTime();
+
+		if ( endtime <= params.time )
+			return true;
+	}
+	return false;
+}
+
+void CChoreoView::SelectEvents( SelectionParams_t& params )
+{
+	if ( !m_pScene )
+		return;
+
+	if ( !m_pClickedActor )
+		return;
+
+	if ( params.type == SelectionParams_t::SP_CHANNEL && !m_pClickedChannel )
+		return;
+
+	//CChoreoActor *actor = m_pClickedActor->GetActor();
+	CChoreoChannel *channel = m_pClickedChannel ? m_pClickedChannel->GetChannel() : NULL;
+
+	for ( int i = 0; i < m_SceneActors.Size(); i++ )
+	{
+		CChoreoActorWidget *a = m_SceneActors[ i ];
+		if ( !a )
+			continue;
+
+		//if ( a->GetActor() != actor )
+		//	continue;
+
+		for ( int j = 0; j < a->GetNumChannels(); j++ )
+		{
+			CChoreoChannelWidget *c = a->GetChannel( j );
+			if ( !c )
+				continue;
+
+			if ( params.type == SelectionParams_t::SP_CHANNEL &&
+				c->GetChannel() != channel )
+				continue;
+
+			if ( params.type == SelectionParams_t::SP_ACTIVE &&
+				!c->GetChannel()->GetActive() )
+				continue;
+
+			for ( int k = 0; k < c->GetNumEvents(); k++ )
+			{
+				CChoreoEventWidget *e = c->GetEvent( k );
+				if ( !e )
+					continue;
+
+				CChoreoEvent *event = e->GetEvent();
+				if ( !event )
+					continue;
+
+				if ( !ShouldSelectEvent( params, event ) )
+					continue;
+
+				e->SetSelected( true );
+			}
+		}
+	}
+
+	// Now handle global events, too
+	for ( int i = 0; i < m_SceneGlobalEvents.Count(); i++ )
+	{
+		CChoreoGlobalEventWidget *e = m_SceneGlobalEvents[ i ];
+		if ( !e )
+			continue;
+
+		CChoreoEvent *event = e->GetEvent();
+		if ( !event )
+			continue;
+
+		if ( !ShouldSelectEvent( params, event ) )
+			continue;
+
+		e->SetSelected( true );
+	}
+
+	redraw();
+}
+
+void CChoreoView::SetTimeZoom( char const *tool, int tz, bool preserveFocus )
+{
+	if ( !m_pScene )
+		return;
+	
+	// No change
+	int oldZoom = GetTimeZoom( tool );
+	if ( tz == oldZoom )
+		return;
+
+	SetDirty( true );
+
+	POINT pt;
+	::GetCursorPos( &pt );
+	::ScreenToClient( (HWND)getHandle(), &pt );
+
+	// Now figure out time under cursor at old zoom scale
+	float t = GetTimeValueForMouse( pt.x, true );
+
+	m_pScene->SetTimeZoom( tool, tz );
+
+	if ( preserveFocus )
+	{
+		RECT rc;
+		GetClientRect( (HWND)getHandle(), &rc );
+		RECT rcClient = rc;
+		rcClient.top += GetStartRow();
+		OffsetRect( &rcClient, 0, -m_nTopOffset );
+		m_flStartTime = m_flLeftOffset / GetPixelsPerSecond();
+		m_flEndTime = m_flStartTime + (float)( rcClient.right - GetLabelWidth() ) / GetPixelsPerSecond();
+
+		// Now figure out tie under pt.x
+		float newT = GetTimeValueForMouse( pt.x, true );
+		if ( newT != t )
+		{
+			// We need to scroll over a bit
+			float pps = GetPixelsPerSecond();
+			float movePixels = pps * ( newT - t );
+
+			m_flLeftOffset -= movePixels;
+			if ( m_flLeftOffset < 0.0f )
+			{
+				//float fixup = - m_flLeftOffset;
+				m_flLeftOffset = 0;
+			}
+
+			// float maxtime = m_pScene->FindStopTime();
+			float flApparentEndTime = max( m_pScene->FindStopTime(), 5.0f ) + 5.0f;
+			if ( m_flEndTime > flApparentEndTime )
+			{
+				movePixels = pps * ( m_flEndTime - flApparentEndTime );
+				m_flLeftOffset = max( 0.0f, m_flLeftOffset - movePixels );
+			}
+		}
+	}
+
+	// Deal with the slider
+	RepositionHSlider();
+	redraw();
+}
+
+int CChoreoView::GetTimeZoom( char const *tool )
+{
+	if ( !m_pScene )
+		return 100;
+
+	return m_pScene->GetTimeZoom( tool );
+}
+
+void CChoreoView::CheckInsertTime( CChoreoEvent *e, float dt, float starttime, float endtime )
+{
+	// Not influenced
+	float eventend = e->HasEndTime() ? e->GetEndTime() : e->GetStartTime();
+	
+	if ( eventend < starttime )
+		return;
+
+	if ( e->GetStartTime() > starttime )
+	{
+		e->OffsetTime( dt );
+		e->SnapTimes();
+	}
+	else if ( !e->IsFixedLength() && e->HasEndTime() ) // the event starts before start, but ends after start time, need to insert space into the event, act like user dragged end time
+	{
+		float newduration = e->GetDuration() + dt;
+		RescaleRamp( e, newduration );
+		switch ( e->GetType() )
+		{
+		default:
+			break;
+		case CChoreoEvent::GESTURE:
+			{
+				e->RescaleGestureTimes( e->GetStartTime(), e->GetEndTime() + dt, true );
+			}
+			break;
+		case CChoreoEvent::FLEXANIMATION:
+			{
+				RescaleExpressionTimes( e, e->GetStartTime(), e->GetEndTime() + dt );
+			}
+			break;
+		}
+		e->OffsetEndTime( dt );
+		e->SnapTimes();
+		e->ResortRamp();
+	}
+
+	switch ( e->GetType() )
+	{
+	default:
+		break;
+	case CChoreoEvent::SPEAK:
+		{
+			// Try and load wav to get length
+			CAudioSource *wave = sound->LoadSound( va( "sound/%s", FacePoser_TranslateSoundName( e ) ) );
+			if ( wave )
+			{
+				e->SetEndTime( e->GetStartTime() + wave->GetRunningLength() );
+				delete wave;
+			}
+		}
+		break;
+	case CChoreoEvent::SEQUENCE:
+		{
+			CheckSequenceLength( e, false );
+		}
+		break;
+	case CChoreoEvent::GESTURE:
+		{
+			CheckGestureLength( e, false );
+		}
+		break;
+	}
+}
+
+void CChoreoView::OnInsertTime()
+{
+	if ( !m_rgABPoints[ 0 ].active &&
+		 !m_rgABPoints[ 1 ].active  )
+	{
+		return;
+	}
+
+	Con_Printf( "OnInsertTime()\n" );
+
+	float starttime = m_rgABPoints[ 0 ].time;
+	float endtime = m_rgABPoints[ 1 ].time;
+
+	// Sort samples correctly
+	if ( starttime > endtime )
+	{
+		float temp = starttime;
+		starttime = endtime;
+		endtime = temp;
+	}
+
+	float dt = endtime - starttime;
+	if ( dt == 0.0f )
+	{
+		// Nothing to do...
+		return;
+	}
+
+	SetDirty( true );
+
+	PushUndo( "Insert Time" );
+
+	for ( int i = 0; i < m_SceneActors.Size(); i++ )
+	{
+		CChoreoActorWidget *actor = m_SceneActors[ i ];
+		if ( !actor )
+			continue;
+
+		for ( int j = 0; j < actor->GetNumChannels(); j++ )
+		{
+			CChoreoChannelWidget *channel = actor->GetChannel( j );
+			if ( !channel )
+				continue;
+
+			for ( int k = 0; k < channel->GetNumEvents(); k++ )
+			{
+				CChoreoEventWidget *event = channel->GetEvent( k );
+				if ( !event )
+					continue;
+
+				CChoreoEvent *e = event->GetEvent();
+				if ( !e )
+					continue;
+
+				CheckInsertTime( e, dt, starttime, endtime );
+			}
+		}
+	}
+
+	// Now handle global events, too
+	for ( int i = 0; i < m_SceneGlobalEvents.Count(); i++ )
+	{
+		CChoreoGlobalEventWidget *event = m_SceneGlobalEvents[ i ];
+		if ( !event )
+			continue;
+
+		CChoreoEvent *e = event->GetEvent();
+		if ( !e )
+			continue;
+
+		CheckInsertTime( e, dt, starttime, endtime );
+	}
+
+	PushRedo( "Insert Time" );
+	InvalidateLayout();
+
+	g_pExpressionTool->LayoutItems( true );
+	g_pExpressionTool->redraw();
+	g_pGestureTool->redraw();
+	g_pRampTool->redraw();
+	g_pSceneRampTool->redraw();
+}
+
+void CChoreoView::CheckDeleteTime( CChoreoEvent *e, float dt, float starttime, float endtime, bool& deleteEvent )
+{
+	deleteEvent = false;
+
+	// Not influenced
+	float eventend = e->HasEndTime() ? e->GetEndTime() : e->GetStartTime();
+
+	if ( eventend < starttime )
+	{
+		return;
+	}
+
+	// On right side of start mark, just shift left
+	if ( e->GetStartTime() > starttime )
+	{
+		// If it has no duration and it's in the bounds then kill it.
+		if ( !e->HasEndTime() && e->GetStartTime() < endtime )
+		{
+			deleteEvent = true;
+			return;
+		}
+		else
+		{
+			float shift = e->GetStartTime() - starttime;
+			float maxoffset = min( dt, shift );
+	
+			e->OffsetTime( -maxoffset );
+			e->SnapTimes();
+		}
+	}
+	else if ( !e->IsFixedLength() && e->HasEndTime() ) // the event starts before start, but ends after start time, need to insert space into the event, act like user dragged end time
+	{
+		float shiftend = e->GetEndTime() - starttime;
+		float maxoffset = min( dt, shiftend );
+
+		float newduration = e->GetDuration() - maxoffset;
+		if ( newduration <= 0.0f )
+		{
+			deleteEvent = true;
+			return;
+		}
+		else
+		{
+			RescaleRamp( e, newduration );
+			switch ( e->GetType() )
+			{
+			default:
+				break;
+			case CChoreoEvent::GESTURE:
+				{
+					e->RescaleGestureTimes( e->GetStartTime(), e->GetEndTime() - maxoffset, true );
+				}
+				break;
+			case CChoreoEvent::FLEXANIMATION:
+				{
+					RescaleExpressionTimes( e, e->GetStartTime(), e->GetEndTime() - maxoffset );
+				}
+				break;
+			}
+			e->OffsetEndTime( -maxoffset );
+			e->SnapTimes();
+			e->ResortRamp();
+		}
+	}
+
+	switch ( e->GetType() )
+	{
+	default:
+		break;
+	case CChoreoEvent::SPEAK:
+		{
+			// Try and load wav to get length
+			CAudioSource *wave = sound->LoadSound( va( "sound/%s", FacePoser_TranslateSoundName( e ) ) );
+			if ( wave )
+			{
+				e->SetEndTime( e->GetStartTime() + wave->GetRunningLength() );
+				delete wave;
+			}
+		}
+		break;
+	case CChoreoEvent::SEQUENCE:
+		{
+			CheckSequenceLength( e, false );
+		}
+		break;
+	case CChoreoEvent::GESTURE:
+		{
+			CheckGestureLength( e, false );
+		}
+		break;
+	}
+}
+
+void CChoreoView::OnDeleteTime()
+{
+	if ( !m_rgABPoints[ 0 ].active &&
+		 !m_rgABPoints[ 1 ].active  )
+	{
+		return;
+	}
+
+	Con_Printf( "OnDeleteTime()\n" );
+
+	float starttime = m_rgABPoints[ 0 ].time;
+	float endtime = m_rgABPoints[ 1 ].time;
+
+	// Sort samples correctly
+	if ( starttime > endtime )
+	{
+		float temp = starttime;
+		starttime = endtime;
+		endtime = temp;
+	}
+
+	float dt = endtime - starttime;
+	if ( dt == 0.0f )
+	{
+		// Nothing to do...
+		return;
+	}
+
+	SetDirty( true );
+
+	PushUndo( "Delete Time" );
+
+	CUtlVector< CChoreoEventWidget * > deletions;
+	CUtlVector< CChoreoGlobalEventWidget * > global_deletions;
+
+	for ( int i = 0; i < m_SceneActors.Size(); i++ )
+	{
+		CChoreoActorWidget *actor = m_SceneActors[ i ];
+		if ( !actor )
+			continue;
+
+		for ( int j = 0; j < actor->GetNumChannels(); j++ )
+		{
+			CChoreoChannelWidget *channel = actor->GetChannel( j );
+			if ( !channel )
+				continue;
+
+			for ( int k = 0; k < channel->GetNumEvents(); k++ )
+			{
+				CChoreoEventWidget *event = channel->GetEvent( k );
+				if ( !event )
+					continue;
+
+				CChoreoEvent *e = event->GetEvent();
+				if ( !e )
+					continue;
+
+				bool deleteEvent = false;
+
+				CheckDeleteTime( e, dt, starttime, endtime, deleteEvent );
+			
+				if ( deleteEvent )
+				{
+					deletions.AddToTail( event );
+				}
+			}
+		}
+	}
+
+	// Now handle global events, too
+	for ( int i = 0; i < m_SceneGlobalEvents.Count(); i++ )
+	{
+		CChoreoGlobalEventWidget *event = m_SceneGlobalEvents[ i ];
+		if ( !event )
+			continue;
+
+		CChoreoEvent *e = event->GetEvent();
+		if ( !e )
+			continue;
+
+		bool deleteEvent = false;
+		CheckDeleteTime( e, dt, starttime, endtime, deleteEvent );
+
+		if ( deleteEvent )
+		{
+			global_deletions.AddToTail( event );
+		}
+	}
+
+	for ( int i = 0; i < deletions.Count(); i++ )
+	{
+		CChoreoEventWidget *w = deletions[ i ];
+
+		CChoreoEvent *e = w->GetEvent();
+		CChoreoChannel *channel = e->GetChannel();
+		if ( channel )
+		{
+			channel->RemoveEvent( e );
+		}
+		m_pScene->DeleteReferencedObjects( e );
+	}
+
+	for ( int i = 0; i < global_deletions.Count(); i++ )
+	{
+		CChoreoGlobalEventWidget *w = global_deletions[ i ];
+		CChoreoEvent *e = w->GetEvent();
+		m_pScene->DeleteReferencedObjects( e );
+	}
+
+	// Force scroll bars to recompute
+	ForceScrollBarsToRecompute( false );
+
+	if ( deletions.Count() > 0 || global_deletions.Count() > 0 )
+	{
+		DeleteSceneWidgets();
+		CreateSceneWidgets();
+	}
+
+	PushRedo( "Delete Time" );
+
+	InvalidateLayout();
+
+	g_pExpressionTool->LayoutItems( true );
+	g_pExpressionTool->redraw();
+	g_pGestureTool->redraw();
+	g_pRampTool->redraw();
+	g_pSceneRampTool->redraw();
+}
+
+void CChoreoView::OnModelChanged()
+{
+	InvalidateTrackLookup();
+	// OnCheckSequenceLengths();
+}
+
+void CChoreoView::SetShowCloseCaptionData( bool show )
+{
+	m_bShowCloseCaptionData = show;
+}
+
+bool CChoreoView::GetShowCloseCaptionData( void ) const
+{
+	return m_bShowCloseCaptionData;
+}
+
+void CChoreoView::OnToggleCloseCaptionTags()
+{
+	m_bShowCloseCaptionData = !m_bShowCloseCaptionData;
+	InvalidateLayout();
+}
+
+
+
+static bool EventStartTimeLessFunc( CChoreoEvent * const &p1, CChoreoEvent * const  &p2 )
+{
+	CChoreoEvent *w1;
+	CChoreoEvent *w2;
+
+	w1 = const_cast< CChoreoEvent * >( p1 );
+	w2 = const_cast< CChoreoEvent * >( p2 );
+
+	return w1->GetStartTime() < w2->GetStartTime();
+}
+
+bool CChoreoView::GenerateCombinedFile( char const *outfilename, char const *cctoken, gender_t gender, CUtlRBTree< CChoreoEvent * >& sorted )
+{
+	CUtlVector< CombinerEntry > work;
+
+	char actualfile[ 512 ];
+	soundemitter->GenderExpandString( gender, outfilename, actualfile, sizeof( actualfile ) );
+	if ( Q_strlen( actualfile ) <= 0 )
+	{
+		return false;
+	}
+
+	int i = sorted.FirstInorder();
+	if ( i != sorted.InvalidIndex() )
+	{
+		CChoreoEvent *e = sorted[ i ];
+
+		float startoffset = e->GetStartTime();
+
+		do
+		{
+			e = sorted[ i ];
+
+			float curoffset = e->GetStartTime();
+
+			CombinerEntry ce;
+			Q_snprintf( ce.wavefile, sizeof( ce.wavefile ), "sound/%s", FacePoser_TranslateSoundNameGender( e->GetParameters(), gender ) );
+			ce.startoffset = curoffset - startoffset;
+
+			work.AddToTail( ce );
+
+			i = sorted.NextInorder( i );
+		}
+		while ( i != sorted.InvalidIndex() );
+	}
+
+	bool ok = soundcombiner->CombineSoundFiles( filesystem, actualfile, work );
+	if ( !ok )
+	{
+		Con_ErrorPrintf( "Failed to create combined sound '%s':'%s'\n", cctoken, actualfile );
+		return false;
+	}
+	Con_Printf( "Created combined sound '%s':'%s'\n", cctoken, actualfile );
+	return true;
+}
+
+bool CChoreoView::ValidateCombinedFileCheckSum( char const *outfilename, char const *cctoken, gender_t gender, CUtlRBTree< CChoreoEvent * >& sorted )
+{
+	CUtlVector< CombinerEntry > work;
+
+	char actualfile[ 512 ];
+	soundemitter->GenderExpandString( gender, outfilename, actualfile, sizeof( actualfile ) );
+	if ( Q_strlen( actualfile ) <= 0 )
+	{
+		return false;
+	}
+
+	int i = sorted.FirstInorder();
+	if ( i != sorted.InvalidIndex() )
+	{
+		CChoreoEvent *e = sorted[ i ];
+
+		float startoffset = e->GetStartTime();
+
+		do
+		{
+			e = sorted[ i ];
+
+			float curoffset = e->GetStartTime();
+
+			CombinerEntry ce;
+			Q_snprintf( ce.wavefile, sizeof( ce.wavefile ), "sound/%s", FacePoser_TranslateSoundNameGender( e->GetParameters(), gender ) );
+			ce.startoffset = curoffset - startoffset;
+
+			work.AddToTail( ce );
+
+			i = sorted.NextInorder( i );
+		}
+		while ( i != sorted.InvalidIndex() );
+	}
+
+	return soundcombiner->IsCombinedFileChecksumValid( filesystem, actualfile, work );
+}
+
+void SuggestCaption( char *dest, int destlen, CUtlVector< CChoreoEvent * >& events )
+{
+	// Walk through events and concatenate current captions, or raw wav data if have any
+	dest[ 0 ] = 0;
+
+	int c = events.Count();
+	for ( int i = 0 ; i < c; ++i )
+	{
+		CChoreoEvent *e = events[ i ];
+
+		bool found = false;
+		char tok[ CChoreoEvent::MAX_CCTOKEN_STRING ];
+		if ( e->GetPlaybackCloseCaptionToken( tok, sizeof( tok ) ) )
+		{
+			wchar_t *localized = g_pLocalize->Find( tok );
+			if ( localized )
+			{
+				found = true;
+
+				char ansi[ 1024 ];
+				g_pLocalize->ConvertUnicodeToANSI( localized, ansi, sizeof( ansi ) );
+				Q_strncat( dest, ansi, destlen, COPY_ALL_CHARACTERS );
+			}
+		}
+		
+		if ( !found )
+		{
+			// See if the wav file has data...
+			CAudioSource *wave = sound->LoadSound( va( "sound/%s", FacePoser_TranslateSoundName( e ) ) );
+			if ( wave )
+			{
+				CSentence *sentence = wave->GetSentence();
+				if ( sentence )
+				{
+					Q_strncat( dest, sentence->GetText(), destlen, COPY_ALL_CHARACTERS );
+					found = true;
+				}
+			}
+		}
+
+		if ( found && Q_strlen( dest ) > 0 && i != c - 1 )
+		{
+			Q_strncat( dest, " ", destlen, COPY_ALL_CHARACTERS );
+		}
+	}
+}
+
+void CChoreoView::OnCombineSpeakEvents()
+{
+	if ( !m_pScene )
+		return;
+
+	CChoreoChannel *firstChannel = NULL;
+
+	CUtlVector< CChoreoEvent * >	selected;
+	GetSelectedEvents( selected );
+
+	int c = selected.Count();
+	// Find the appropriate event by iterating across all actors and channels
+	for ( int i = c - 1; i >= 0; --i )
+	{
+		CChoreoEvent *e = selected[ i ];
+
+		if ( e->GetType() != CChoreoEvent::SPEAK )
+		{
+			Con_ErrorPrintf( "Can't combine events, all events must be SPEAK events.\n" );
+			return;
+		}
+
+		if ( !firstChannel )
+		{
+			firstChannel = e->GetChannel();
+		}
+		else if ( e->GetChannel() != firstChannel )
+		{
+			Con_ErrorPrintf( "Can't combine events, all events must reside in the same channel.\n" );
+			return;
+		}
+	}
+
+	if ( selected.Count() < 2 )
+	{
+		Con_ErrorPrintf( "Can't combine events, must have at least two events selected.\n" );
+		return;
+	}
+
+	// Let the user pick a CC phrase
+	CCloseCaptionLookupParams params;
+	Q_strncpy( params.m_szDialogTitle, "Choose Close Caption Token", sizeof( params.m_szDialogTitle ) );
+
+	params.m_bPositionDialog = false;
+	params.m_nLeft = 0;
+	params.m_nTop = 0;
+
+	char playbacktoken[ CChoreoEvent::MAX_CCTOKEN_STRING ];
+	if ( !selected[0]->GetPlaybackCloseCaptionToken( playbacktoken, sizeof( playbacktoken ) ) )
+	{
+		return;
+	}
+
+	if ( !Q_stristr( playbacktoken, "_cc" ) )
+	{
+		Q_strncpy( params.m_szCCToken, va( "%s_cc", playbacktoken ), sizeof( params.m_szCCToken ) );
+	}
+	else
+	{
+		Q_strncpy( params.m_szCCToken, va( "%s", playbacktoken ), sizeof( params.m_szCCToken ) );
+	}
+
+	// User hit okay and value actually changed?
+	if ( !CloseCaptionLookup( &params ) &&
+		params.m_szCCToken[0] != 0 )
+	{
+		return;
+	}
+
+	// See if the token exists?
+	StringIndex_t stringIndex = g_pLocalize->FindIndex( params.m_szCCToken );
+	if ( INVALID_LOCALIZE_STRING_INDEX == stringIndex )
+	{
+		// Add token to closecaption_english file.
+		// Guess at string and ask user to confirm.
+		CInputParams ip;
+		memset( &ip, 0, sizeof( ip ) );
+
+		Q_strncpy( ip.m_szDialogTitle, "Add Close Caption", sizeof( ip.m_szDialogTitle ) );
+		Q_snprintf( ip.m_szPrompt, sizeof( ip.m_szPrompt ), "Token (%s):", params.m_szCCToken );
+
+		char suggested[ 2048 ];
+
+		SuggestCaption( suggested, sizeof( suggested ), selected );
+
+		Q_snprintf( ip.m_szInputText, sizeof( ip.m_szInputText ), "%s", suggested );
+
+		if ( !InputProperties( &ip ) )
+		{
+			Con_Printf( "Combining of sound events cancelled\n" );
+			return;
+		}
+
+		if ( Q_strlen( ip.m_szInputText ) == 0 )
+		{
+			Q_snprintf( ip.m_szInputText, sizeof( ip.m_szInputText ), "!!!%s", params.m_szCCToken );
+		}
+
+		char const *captionFile = "resource/closecaption_english.txt";
+
+		if ( !filesystem->IsFileWritable( captionFile, "GAME" ) )
+		{
+			Warning( "Forcing %s to be writable!!!\n", captionFile );
+			MakeFileWriteable( captionFile );
+		}
+
+		wchar_t unicode[ 2048 ];
+		g_pLocalize->ConvertANSIToUnicode( ip.m_szInputText, unicode, sizeof( unicode ) );
+
+		g_pLocalize->AddString( params.m_szCCToken, unicode, captionFile );
+		g_pLocalize->SaveToFile( captionFile );
+	}
+
+	SetDirty( true );
+
+	PushUndo( "Combine Sound Events" );
+
+	c = selected.Count();
+	for ( int i = 0 ; i < c; ++i )
+	{
+		selected[ i ]->SetCloseCaptionToken( params.m_szCCToken );
+	}
+
+	PushRedo( "Combine Sound Events" );
+
+	// Redraw
+	InvalidateLayout();
+
+	Con_Printf( "Changed %i events to use close caption token '%s'\n", c, params.m_szCCToken );
+
+	// Sort the sounds by start time
+
+	CUtlRBTree< CChoreoEvent * >  sorted( 0, 0, EventStartTimeLessFunc );
+
+	// Sort items
+	c = selected.Count();
+	bool genderwildcard = false;
+	for ( int i = 0; i < c; i++ )
+	{
+		CChoreoEvent *e = selected[ i ];
+		sorted.Insert( e );
+
+		// Get the sound entry name and use it to look up the gender info
+		// Look up the sound level from the soundemitter system
+		if ( !genderwildcard )
+		{
+			genderwildcard = soundemitter->IsUsingGenderToken( e->GetParameters() );
+		}
+	}
+
+
+	char outfilename[ 512 ];
+	Q_memset( outfilename, 0, sizeof( outfilename ) );
+
+	CChoreoEvent *e = sorted[ sorted.FirstInorder() ];
+
+	// Update whether we use the $gender token
+	e->SetCombinedUsingGenderToken( genderwildcard );
+
+	if ( !e->ComputeCombinedBaseFileName( outfilename, sizeof( outfilename ), genderwildcard ) )
+	{
+		Con_ErrorPrintf( "Unable to regenerate wav file name for combined sound\n" );
+		return;
+	}
+
+	int soundindex = soundemitter->GetSoundIndex( e->GetParameters() );
+	char const *scriptfile = soundemitter->GetSourceFileForSound( soundindex );
+	if ( !scriptfile || !scriptfile[0] )
+	{
+		Con_ErrorPrintf( "Unable to find existing script to use for new combined sound entry.\n" );
+		return;
+	}
+
+	// Create a new sound entry for this sound
+	CAddSoundParams asp;
+	Q_memset( &asp, 0, sizeof( asp ) );
+	Q_strncpy( asp.m_szDialogTitle, "Add Combined Sound Entry", sizeof( asp.m_szDialogTitle ) );
+	Q_strncpy( asp.m_szWaveFile, outfilename + Q_strlen( "sound/"), sizeof( asp.m_szWaveFile ) );
+	Q_strncpy( asp.m_szScriptName, scriptfile, sizeof( asp.m_szScriptName ) );
+	Q_strncpy( asp.m_szSoundName, params.m_szCCToken, sizeof( asp.m_szSoundName ) );
+
+	asp.m_bAllowExistingSound = true;
+	asp.m_bReadOnlySoundName = true;
+
+	if ( !AddSound( &asp, (HWND)g_MDLViewer->getHandle() ) )
+	{
+		return;
+	}
+
+	if ( genderwildcard )
+	{
+		GenerateCombinedFile( outfilename, params.m_szCCToken, GENDER_MALE, sorted );
+		GenerateCombinedFile( outfilename, params.m_szCCToken, GENDER_FEMALE, sorted );
+	}
+	else
+	{
+		GenerateCombinedFile( outfilename, params.m_szCCToken, GENDER_NONE, sorted );
+	}
+}
+
+bool CChoreoView::ValidateCombinedSoundCheckSum( CChoreoEvent *e )
+{
+	if ( !e || e->GetType() != CChoreoEvent::SPEAK )
+		return false;
+
+	bool genderwildcard = e->IsCombinedUsingGenderToken();
+	char outfilename[ 512 ];
+	Q_memset( outfilename, 0, sizeof( outfilename ) );
+	if ( !e->ComputeCombinedBaseFileName( outfilename, sizeof( outfilename ), genderwildcard ) )
+	{
+		Con_ErrorPrintf( "Unable to regenerate wav file name for combined sound (%s)\n", e->GetCloseCaptionToken() );
+		return false;
+	}
+
+	bool checksumvalid = false;
+
+	CUtlRBTree< CChoreoEvent * > eventList( 0, 0, EventStartTimeLessFunc );
+
+	if ( !e->GetChannel()->GetSortedCombinedEventList( e->GetCloseCaptionToken(), eventList ) )
+	{
+		Con_ErrorPrintf( "Unable to generated combined event list (%s)\n", e->GetCloseCaptionToken() );
+		return false;
+	}
+
+
+	if ( genderwildcard )
+	{
+		checksumvalid = ValidateCombinedFileCheckSum( outfilename, e->GetCloseCaptionToken(), GENDER_MALE, eventList );
+		checksumvalid &= ValidateCombinedFileCheckSum( outfilename, e->GetCloseCaptionToken(), GENDER_FEMALE, eventList );
+	}
+	else
+	{
+		checksumvalid = ValidateCombinedFileCheckSum( outfilename, e->GetCloseCaptionToken(), GENDER_NONE, eventList );
+	}
+
+	return checksumvalid;
+}
+
+void CChoreoView::OnRemoveSpeakEventFromGroup()
+{
+	if ( !m_pScene )
+		return;
+
+	int i, c;
+
+	CUtlVector< CChoreoEvent * >	selected;
+	CUtlVector< CChoreoEvent * >	processlist;
+	if ( GetSelectedEvents( selected ) > 0 )
+	{
+
+		int c = selected.Count();
+		// Find the appropriate event by iterating across all actors and channels
+		for ( i = c - 1; i >= 0; --i )
+		{
+			CChoreoEvent *e = selected[ i ];
+			if ( e->GetType() != CChoreoEvent::SPEAK )
+			{
+				selected.Remove( i );
+				continue;
+			}
+
+			if ( e->GetCloseCaptionType() == CChoreoEvent::CC_DISABLED )
+			{
+				selected.Remove( i );
+				continue;
+			}
+
+			m_pClickedChannel->GetMasterAndSlaves( e, processlist );
+		}
+	}
+	else
+	{
+		m_pClickedChannel->GetMasterAndSlaves( m_pClickedChannel->GetCaptionClickedEvent(), processlist );
+	}
+
+	if ( selected.Count() < 1 )
+	{
+		Con_ErrorPrintf( "No eligible SPEAK event selected.\n" );
+		return;
+	}
+
+	SetDirty( true );
+
+	PushUndo( "Remove speak event(s)" );
+
+	c = processlist.Count();
+	for ( i = 0 ; i < c; ++i )
+	{
+		processlist[ i ]->SetCloseCaptionToken( "" );
+		processlist[ i ]->SetCloseCaptionType( CChoreoEvent::CC_MASTER );
+		processlist[ i ]->SetUsingCombinedFile( false );
+		processlist[ i ]->SetRequiredCombinedChecksum( 0 );
+		processlist[ i ]->SetNumSlaves( 0 );
+		processlist[ i ]->SetLastSlaveEndTime( 0.0f );
+	}
+
+	PushRedo( "Remove speak event(s)" );
+
+	// Redraw
+	InvalidateLayout();
+	Con_Printf( "Reverted %i events to use default close caption token\n", c );
+}
+
+bool CChoreoView::AreSelectedEventsCombinable()
+{
+	CUtlVector< CChoreoEvent * > events;
+	if ( GetSelectedEvents( events ) <= 0 )
+		return false;
+
+	CChoreoChannel *firstChannel = NULL;
+
+	CUtlVector< CChoreoEvent * >	selected;
+	GetSelectedEvents( selected );
+
+	int c = selected.Count();
+	// Find the appropriate event by iterating across all actors and channels
+	for ( int i = c - 1; i >= 0; --i )
+	{
+		CChoreoEvent *e = selected[ i ];
+
+		if ( e->GetType() != CChoreoEvent::SPEAK )
+		{
+			return false;
+		}
+
+		if ( !firstChannel )
+		{
+			firstChannel = e->GetChannel();
+		}
+		else if ( e->GetChannel() != firstChannel )
+		{
+			return false;
+		}
+	}
+	return selected.Count() >= 2 ? true : false;
+}
+
+bool CChoreoView::AreSelectedEventsInSpeakGroup()
+{
+	CUtlVector< CChoreoEvent * > selected;
+	if ( GetSelectedEvents( selected ) <= 0 )
+	{
+		if ( m_pClickedChannel )
+		{
+			CChoreoEvent *e = m_pClickedChannel->GetCaptionClickedEvent();
+			if ( e && e->GetCloseCaptionType() == CChoreoEvent::CC_MASTER &&
+				 e->GetNumSlaves() >= 1 )
+			{
+				return true;
+			}
+		}
+		return false;
+	}
+
+	int c = selected.Count();
+	// Find the appropriate event by iterating across all actors and channels
+	for ( int i = c - 1; i >= 0; --i )
+	{
+		CChoreoEvent *e = selected[ i ];
+		if ( e->GetType() != CChoreoEvent::SPEAK )
+		{
+			selected.Remove( i );
+			continue;
+		}
+
+		if ( e->GetCloseCaptionType() == CChoreoEvent::CC_DISABLED )
+		{
+			selected.Remove( i );
+			continue;
+		}
+	}
+
+	return selected.Count() >= 1 ? true : false;
+
+}
+
+void CChoreoView::OnChangeCloseCaptionToken( CChoreoEvent *e )
+{
+	CCloseCaptionLookupParams params;
+	Q_strncpy( params.m_szDialogTitle, "Close Caption Token Lookup", sizeof( params.m_szDialogTitle ) );
+
+	params.m_bPositionDialog = false;
+	params.m_nLeft = 0;
+	params.m_nTop = 0;
+	// strcpy( params.m_szPrompt, "Choose model:" );
+
+	Q_strncpy( params.m_szCCToken, e->GetCloseCaptionToken(), sizeof( params.m_szCCToken ) );
+
+	// User hit okay and value actually changed?
+	if ( CloseCaptionLookup( &params ) && 
+		Q_stricmp( e->GetCloseCaptionToken(), params.m_szCCToken ) )
+	{
+		char oldToken[ CChoreoEvent::MAX_CCTOKEN_STRING ];
+		Q_strncpy( oldToken, e->GetCloseCaptionToken(), sizeof( oldToken ) );
+
+		CUtlVector< CChoreoEvent * > events;
+		m_pClickedChannel->GetMasterAndSlaves( e, events );
+
+		if ( events.Count() < 2 )
+		{
+			Con_ErrorPrintf( "Can't combine events, must have at least two events selected.\n" );
+		}
+
+		SetDirty( true );
+
+		PushUndo( "Change closecaption token" );
+
+		// Make the change...
+		int c = events.Count();
+		for ( int i = 0 ; i < c; ++i )
+		{
+			events[i]->SetCloseCaptionToken( params.m_szCCToken );
+		}
+
+		PushRedo( "Change closecaption token" );
+
+		InvalidateLayout();
+
+		Con_Printf( "Close Caption token for '%s' changed to '%s'\n", e->GetName(), params.m_szCCToken );
+	}
+}
+
+void CChoreoView::OnToggleCloseCaptionsForEvent()
+{
+	if ( !m_pClickedChannel )
+	{
+		return;
+	}
+
+	CChoreoEvent *e = m_pClickedChannel->GetCaptionClickedEvent();
+
+	if ( !e )
+	{
+		return;
+	}
+
+	CChoreoEvent::CLOSECAPTION newType = CChoreoEvent::CC_MASTER;
+	// Can't mess with slave
+	switch ( e->GetCloseCaptionType() )
+	{
+	default:
+	case CChoreoEvent::CC_SLAVE:
+		return;
+	case CChoreoEvent::CC_MASTER:
+		newType = CChoreoEvent::CC_DISABLED;
+		break;
+	case CChoreoEvent::CC_DISABLED:
+		newType = CChoreoEvent::CC_MASTER;
+		break;
+	}
+
+	SetDirty( true );
+
+	PushUndo( "Enable/disable captions" );
+
+	// Make the change...
+	e->SetCloseCaptionType( newType );
+
+	PushRedo( "Enable/disable captions" );
+
+	InvalidateLayout();
+
+	Con_Printf( "Close Caption type for '%s' changed to '%s'\n", e->GetName(), CChoreoEvent::NameForCCType( newType ) );
+
+}
+
+void CChoreoView::StopScene()
+{
+	SetScrubTargetTime( m_flScrub );
+	FinishSimulation();
+	sound->Flush();
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+// Input  :  - 
+//-----------------------------------------------------------------------------
+template <class T>
+void DeleteAllAndPurge( T &tree )
+{
+	T::IndexType_t i;
+
+	for ( i = tree.FirstInorder(); i != T::InvalidIndex(); i = tree.NextInorder( i ) )
+	{
+		delete tree[i];
+	}
+
+	tree.Purge();
+}
+
+void CChoreoView::OnPlaceNextSpeakEvent()
+{
+	CUtlVector< CChoreoEvent * > list;
+	GetSelectedEvents( list );
+	if ( list.Count() != 1 )
+	{
+		Warning( "Can't place sound event, nothing selected\n" );
+		return;
+	}
+
+	CChoreoEvent *ev = list[ 0 ];
+	if ( ev->GetType() != CChoreoEvent::SPEAK )
+	{
+		Warning( "Can't place sound event, no previous sound event selected\n" );
+		return;
+	}
+
+	CChoreoChannelWidget *widget = FindChannelForEvent( ev );
+	if ( !widget )
+	{
+		Warning( "Can't place sound event, can't find channel widget for event\n" );
+		return;
+	}
+
+	CChoreoChannel *channel = widget->GetChannel();
+	if ( !channel )
+	{
+		Warning( "Can't place sound event, can't find channel for new event\n" );
+		return;
+	}
+
+	CUtlRBTree< char const *, int >		m_SortedNames( 0, 0, NameLessFunc );
+
+	int c = soundemitter->GetSoundCount();
+	for ( int i = 0; i < c; i++ )
+	{
+		char const *name = soundemitter->GetSoundName( i );
+		if ( name && name[ 0 ] )
+		{
+			m_SortedNames.Insert( strdup( name ) );
+		}
+	}
+
+	int idx = m_SortedNames.Find( ev->GetParameters() );
+	if ( idx == m_SortedNames.InvalidIndex() )
+	{
+		Warning( "Can't place sound event, can't find '%s' in sound list\n", ev->GetParameters() );
+		DeleteAllAndPurge( m_SortedNames );
+		return;
+	}
+
+	int nextIdx = m_SortedNames.NextInorder( idx );
+	if ( nextIdx == m_SortedNames.InvalidIndex() )
+	{
+		Warning( "Can't place sound event, can't next sound after '%s' in sound list\n", ev->GetParameters() );
+		DeleteAllAndPurge( m_SortedNames );
+		return;
+	}
+
+	DeselectAll();
+
+	SetDirty( true );
+
+	PushUndo( "Place Next Speak Event" );
+
+	CChoreoEvent *event = m_pScene->AllocEvent();
+	Assert( event );
+	if ( event )
+	{
+		// Copy everything for source event
+		*event = *ev;
+
+		event->SetParameters( m_SortedNames[ nextIdx ] );
+		// Start it at the end time...
+		event->SetStartTime( event->GetEndTime() );
+		event->SetResumeCondition( false );
+		event->ClearAllRelativeTags();
+		event->ClearAllTimingTags();
+		event->ClearAllAbsoluteTags( CChoreoEvent::PLAYBACK );
+		event->ClearAllAbsoluteTags( CChoreoEvent::ORIGINAL );
+
+		event->SetChannel( channel );
+		event->SetActor( channel->GetActor() );
+
+		// Try and load wav to get length
+		CAudioSource *wave = sound->LoadSound( va( "sound/%s", FacePoser_TranslateSoundName( event ) ) );
+		if ( wave )
+		{
+			event->SetEndTime( event->GetStartTime() + wave->GetRunningLength() );
+			delete wave;
+		}
+
+		DeleteSceneWidgets();
+
+		// Add to appropriate channel
+		channel->AddEvent( event );
+
+		CreateSceneWidgets();
+
+		CChoreoEventWidget *eventWidget = FindWidgetForEvent( event );
+		if ( eventWidget )
+		{
+			eventWidget->SetSelected( true );
+		}
+	
+		// Redraw
+		InvalidateLayout();
+	}
+
+	PushRedo( "Place Next Speak Event" );
+
+	DeleteAllAndPurge( m_SortedNames );
+}
+
+enum
+{
+	FM_LEFT = 0,
+	FM_RIGHT,
+	FM_SMALLESTWIDE,
+	FM_LARGESTWIDE
+};
+
+static int FindMetric( int type, CUtlVector< CChoreoEvent * > &list, float& value )
+{
+	float bestVal = 999999.0f;
+	int bestIndex = -1;
+	bool greater = true;
+
+	switch ( type )
+	{
+	default:
+	case FM_LEFT:
+	case FM_SMALLESTWIDE:
+		greater = false;
+		break;
+	case FM_RIGHT:
+	case FM_LARGESTWIDE:
+		bestVal = -bestVal;
+		greater = true;
+		break;
+	}
+	int c = list.Count();
+	for ( int i = 0; i < c; ++i )
+	{
+		CChoreoEvent *e = list[ i ];
+		if ( type != FM_LEFT &&
+			!e->HasEndTime() )
+			continue;
+
+		float val;
+		switch ( type )
+		{
+		default:
+		case FM_LEFT:
+			val = e->GetStartTime();
+			break;
+		case FM_RIGHT:
+			val = e->GetEndTime();
+			break;
+		case FM_SMALLESTWIDE:
+		case FM_LARGESTWIDE:
+			val = e->GetDuration();
+			break;
+		}
+
+		if ( greater )
+		{
+			if ( val <= bestVal )
+				continue;
+		}
+		else
+		{
+			if ( val >= bestVal )
+				continue;
+		}
+
+		bestVal		= val;
+		bestIndex	= i;
+	}
+
+	value = bestVal;
+	return bestIndex;
+}
+
+void CChoreoView::OnAlign( bool left )
+{
+	CUtlVector< CChoreoEvent * > list;
+	GetSelectedEvents( list );
+
+	if ( left )
+	{
+		for ( int i = 0; i < m_SceneGlobalEvents.Size(); i++ )
+		{
+			CChoreoGlobalEventWidget *event = m_SceneGlobalEvents[ i ];
+			if ( !event || !event->IsSelected() )
+				continue;
+
+			list.AddToTail( event->GetEvent() );
+		}
+	}
+
+	int numSel = list.Count();
+	if ( numSel < 2 )
+	{
+		Warning( "Can't align, must have at least two events selected\n" );
+		return;
+	}
+
+	float value;
+	int idx = FindMetric( left ? FM_LEFT : FM_RIGHT, list, value );
+	if ( idx == -1 )
+	{
+		return;
+	}
+
+	SetDirty( true );
+
+	char undotext[ 128 ];
+	Q_snprintf( undotext, sizeof( undotext ), "Align %s", left ? "Left" : "Right" );
+	PushUndo( undotext );
+
+	for ( int i = 0; i < numSel; ++i )
+	{
+		if ( i == idx )
+			continue;
+
+		CChoreoEvent *e = list[ i ];
+
+		float newStartTime = left ? value : ( value - e->GetDuration() );
+		float offset = newStartTime - e->GetStartTime();
+		e->OffsetTime( offset );
+	}
+
+	PushRedo( undotext );
+
+	InvalidateLayout();
+}
+
+void CChoreoView::OnMakeSameSize( bool smallest )
+{
+	CUtlVector< CChoreoEvent * > list;
+	int numSel = GetSelectedEvents( list );
+	if ( numSel < 2 )
+	{
+		Warning( "Can't align, must have at least two events selected\n" );
+		return;
+	}
+
+	float value;
+	int idx = FindMetric( smallest ? FM_SMALLESTWIDE : FM_LARGESTWIDE, list, value );
+	if ( idx == -1 )
+	{
+		return;
+	}
+
+	SetDirty( true );
+
+	char undotext[ 128 ];
+	Q_snprintf( undotext, sizeof( undotext ), "Size to %s", smallest ? "Smallest" : "Largest" );
+	PushUndo( undotext );
+
+	for ( int i = 0; i < numSel; ++i )
+	{
+		if ( i == idx )
+			continue;
+
+		list[ i ]->SetEndTime( list[ i ]->GetStartTime() + value );
+	}
+
+	PushRedo( undotext );
+
+	InvalidateLayout();
+}
+
+void CChoreoView::SelectAllEventsInActor( CChoreoActorWidget *actor )
+{
+	TraverseWidgets( &CChoreoView::SelectInActor, actor );
+	redraw();
+}
+
+void CChoreoView::SelectAllEventsInChannel( CChoreoChannelWidget *channel )
+{
+	TraverseWidgets( &CChoreoView::SelectInChannel, channel );
+	redraw();
+}
+
+void CChoreoView::SelectInActor( CChoreoWidget *widget, CChoreoWidget *param1 )
+{
+	CChoreoEventWidget *ev = dynamic_cast< CChoreoEventWidget * >( widget );
+	if ( !ev )
+		return;
+
+	if ( ev->IsSelected() )
+		return;
+
+	CChoreoChannel *ch = ev->GetEvent()->GetChannel();
+	if ( !ch )
+		return;
+	CChoreoActor *actor = ch->GetActor();
+	if ( !actor )
+		return;
+
+	CChoreoActorWidget *actorw = dynamic_cast< CChoreoActorWidget * >( param1 );
+	if ( !actorw )
+		return;
+
+	if ( actorw->GetActor() != actor )
+		return;
+
+	widget->SetSelected( true );
+}
+
+void CChoreoView::SelectInChannel( CChoreoWidget *widget, CChoreoWidget *param1 )
+{
+	CChoreoEventWidget *ev = dynamic_cast< CChoreoEventWidget * >( widget );
+	if ( !ev )
+		return;
+
+	if ( ev->IsSelected() )
+		return;
+
+	CChoreoChannel *ch = ev->GetEvent()->GetChannel();
+	if ( !ch )
+		return;
+
+	CChoreoChannelWidget *chw = dynamic_cast< CChoreoChannelWidget * >( param1 );
+	if ( !chw )
+		return;
+
+	if ( chw->GetChannel() != ch )
+		return;
+
+	widget->SetSelected( true );
+}
+