1HEADmaster

1 files changed, 8799 insertions, 0 deletions

diff --git a/utils/hlfaceposer/phonemeeditor.cpp b/utils/hlfaceposer/phonemeeditor.cpp
new file mode 100644
index 0000000..e33f6c1
--- /dev/null
+++ b/utils/hlfaceposer/phonemeeditor.cpp
@@ -0,0 +1,8799 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+// Purpose: 
+//
+// $NoKeywords: $
+//===========================================================================//
+#include <Assert.h>
+#include <stdio.h>
+#include <math.h>
+#include "hlfaceposer.h"
+#include "PhonemeEditor.h"
+#include "PhonemeEditorColors.h"
+#include "snd_audio_source.h"
+#include "snd_wave_source.h"
+#include "ifaceposersound.h"
+#include "choreowidgetdrawhelper.h"
+#include "mxBitmapButton.h"
+#include "phonemeproperties.h"
+#include "tier2/riff.h"
+#include "StudioModel.h"
+#include "expressions.h"
+#include "expclass.h"
+#include "InputProperties.h"
+#include "phonemeextractor/PhonemeExtractor.h"
+#include "PhonemeConverter.h"
+#include "choreoevent.h"
+#include "choreoscene.h"
+#include "ChoreoView.h"
+#include "filesystem.h"
+#include "UtlBuffer.h"
+#include "AudioWaveOutput.h"
+#include "StudioModel.h"
+#include "viewerSettings.h"
+#include "ControlPanel.h"
+#include "faceposer_models.h"
+#include "tier1/strtools.h"
+#include "tabwindow.h"
+#include "MatSysWin.h"
+#include "soundflags.h"
+#include "mdlviewer.h"
+#include "filesystem_init.h"
+#include "WaveBrowser.h"
+#include "tier2/p4helpers.h"
+#include "vstdlib/random.h"
+
+extern IUniformRandomStream *random;
+
+float SnapTime( float input, float granularity );
+
+#define MODE_TAB_OFFSET 20
+
+// 10x magnification
+#define MAX_TIME_ZOOM 1000
+// 10% per step
+#define TIME_ZOOM_STEP 2
+
+#define SCRUBBER_HEIGHT	15
+
+#define TAG_TOP ( 25 + SCRUBBER_HEIGHT )
+#define TAG_BOTTOM ( TAG_TOP + 20 )
+
+#define PLENTY_OF_TIME 99999.9
+#define MINIMUM_WORD_GAP 0.02f
+#define MINIMUM_PHONEME_GAP 0.01f
+#define DEFAULT_WORD_LENGTH 0.25f
+#define DEFAULT_PHONEME_LENGTH 0.1f
+
+#define WORD_DATA_EXTENSION	".txt"
+
+// #define ITEM_GAP_EPSILON 0.0025f
+struct PhonemeEditorColor
+{
+	int				color_number; // For readability
+	int				mode_number; // -1 for all
+	COLORREF		root_color;
+	COLORREF		gray_color;  // if mode is wrong...
+};
+
+static PhonemeEditorColor g_PEColors[ NUM_COLORS ] =
+{
+	{ COLOR_PHONEME_BACKGROUND,					-1, RGB( 240, 240, 220 ) },
+	{ COLOR_PHONEME_TEXT,						-1,	RGB( 63, 63, 63 ) },
+	{ COLOR_PHONEME_LIGHTTEXT,					0,	RGB( 180, 180, 120 ) },
+	{ COLOR_PHONEME_PLAYBACKTICK,				0,	RGB( 255, 0, 0 ) },
+	{ COLOR_PHONEME_WAVDATA,					0,	RGB( 128, 31, 63 ) },
+	{ COLOR_PHONEME_TIMELINE,					0,	RGB( 31, 31, 127 ) },
+	{ COLOR_PHONEME_TIMELINE_MAJORTICK,			0,	RGB( 200, 200, 255 ) },
+	{ COLOR_PHONEME_TIMELINE_MINORTICK,			0,	RGB( 210, 210, 240 ) },
+	{ COLOR_PHONEME_EXTRACTION_RESULT_FAIL,		0,	RGB( 180, 180, 0 ) },
+	{ COLOR_PHONEME_EXTRACTION_RESULT_SUCCESS,	0,	RGB( 100, 180, 100 ) },
+	{ COLOR_PHONEME_EXTRACTION_RESULT_ERROR,	0,	RGB( 255, 31, 31 ) },
+	{ COLOR_PHONEME_EXTRACTION_RESULT_OTHER,	0,	RGB( 63, 63, 63 ) },
+	{ COLOR_PHONEME_TAG_BORDER,					0,	RGB( 160, 100, 100 ) },
+	{ COLOR_PHONEME_TAG_BORDER_SELECTED,		0,	RGB( 255, 40, 60 ) },
+	{ COLOR_PHONEME_TAG_FILLER_NORMAL,			0,	RGB( 210, 210, 190 ) },
+	{ COLOR_PHONEME_TAG_SELECTED,				0,	RGB( 200, 130, 130 ) },
+	{ COLOR_PHONEME_TAG_TEXT,					0,	RGB( 63, 63, 63 ) },
+	{ COLOR_PHONEME_TAG_TEXT_SELECTED,			0,	RGB( 250, 250, 250 ) },
+	{ COLOR_PHONEME_WAV_ENDPOINT,				0,	RGB( 0, 0, 200 ) },
+	{ COLOR_PHONEME_AB,							0,	RGB( 63, 190, 210 ) },
+	{ COLOR_PHONEME_AB_LINE,					0,	RGB( 31, 150, 180 ) },
+	{ COLOR_PHONEME_AB_TEXT,					0,	RGB( 100, 120, 120 ) },
+	{ COLOR_PHONEME_ACTIVE_BORDER,				0,	RGB( 150, 240, 180 ) },
+	{ COLOR_PHONEME_SELECTED_BORDER,			0,	RGB( 255, 0, 0 ) },
+	{ COLOR_PHONEME_TIMING_TAG,					-1,	RGB( 0, 100, 200 ) },
+
+	{ COLOR_PHONEME_EMPHASIS_BG,				1,	RGB( 230, 230, 200 ) },
+	{ COLOR_PHONEME_EMPHASIS_BG_STRONG,			1,	RGB( 163, 201, 239 ) },
+	{ COLOR_PHONEME_EMPHASIS_BG_WEAK,			1,	RGB( 237, 239, 163 ) },
+	{ COLOR_PHONEME_EMPHASIS_BORDER,			1,	RGB( 200, 200, 200 ) },
+	{ COLOR_PHONEME_EMPHASIS_LINECOLOR,			1,	RGB( 0, 0, 255 ) },
+	{ COLOR_PHONEME_EMPHASIS_DOTCOLOR,			1,	RGB( 0, 0, 255 ) },
+	{ COLOR_PHONEME_EMPHASIS_DOTCOLOR_SELECTED,	1,	RGB( 240, 80, 20 ) },
+	{ COLOR_PHONEME_EMPHASIS_TEXT,				1,	RGB( 0, 0, 0 ) },
+	{ COLOR_PHONEME_EMPHASIS_MIDLINE,			1,	RGB( 100, 150, 200 ) },
+};
+
+struct Extractor
+{
+	PE_APITYPE			apitype;
+	CSysModule			*module;
+	IPhonemeExtractor	*extractor;
+};
+
+CUtlVector< Extractor >	g_Extractors;
+
+
+bool DoesExtractorExistFor( PE_APITYPE type )
+{
+	for ( int i=0; i < g_Extractors.Count(); i++ )
+	{
+		if ( g_Extractors[i].apitype == type )
+			return true;
+	}
+	return false;
+}
+
+
+//-----------------------------------------------------------------------------
+// Purpose: Implements the RIFF i/o interface on stdio
+//-----------------------------------------------------------------------------
+class StdIOReadBinary : public IFileReadBinary
+{
+public:
+	int open( const char *pFileName )
+	{
+		return (int)filesystem->Open( pFileName, "rb" );
+	}
+
+	int read( void *pOutput, int size, int file )
+	{
+		if ( !file )
+			return 0;
+
+		return filesystem->Read( pOutput, size, (FileHandle_t)file );
+	}
+
+	void seek( int file, int pos )
+	{
+		if ( !file )
+			return;
+
+		filesystem->Seek( (FileHandle_t)file, pos, FILESYSTEM_SEEK_HEAD );
+	}
+
+	unsigned int tell( int file )
+	{
+		if ( !file )
+			return 0;
+
+		return filesystem->Tell( (FileHandle_t)file );
+	}
+
+	unsigned int size( int file )
+	{
+		if ( !file )
+			return 0;
+
+		return filesystem->Size( (FileHandle_t)file );
+	}
+
+	void close( int file )
+	{
+		if ( !file )
+			return;
+
+		filesystem->Close( (FileHandle_t)file );
+	}
+};
+
+class StdIOWriteBinary : public IFileWriteBinary
+{
+public:
+	int create( const char *pFileName )
+	{
+		MakeFileWriteable( pFileName );
+		return (int)filesystem->Open( pFileName, "wb" );
+	}
+
+	int write( void *pData, int size, int file )
+	{
+		return filesystem->Write( pData, size, (FileHandle_t)file );
+	}
+
+	void close( int file )
+	{
+		filesystem->Close( (FileHandle_t)file );
+	}
+
+	void seek( int file, int pos )
+	{
+		filesystem->Seek( (FileHandle_t)file, pos, FILESYSTEM_SEEK_HEAD );
+	}
+
+	unsigned int tell( int file )
+	{
+		return filesystem->Tell( (FileHandle_t)file );
+	}
+};
+
+// Interface objects
+static StdIOWriteBinary io_out;
+static StdIOReadBinary io_in;
+
+class CPhonemeModeTab : public CTabWindow
+{
+public:
+	typedef CTabWindow BaseClass;
+
+	CPhonemeModeTab( mxWindow *parent, int x, int y, int w, int h, int id = 0, int style = 0 ) :
+		CTabWindow( parent, x, y, w, h, id, style )
+	{
+		SetInverted( true );
+	}
+
+	virtual void ShowRightClickMenu( int mx, int my )
+	{
+		// Nothing
+	}
+
+	void	Init( void )
+	{
+		add( "Phonemes" );
+		add( "Emphasis" );
+		select( 0 );
+	}
+};
+
+PhonemeEditor * g_pPhonemeEditor = 0;
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+// Input  : *parent - 
+//-----------------------------------------------------------------------------
+PhonemeEditor::PhonemeEditor( mxWindow *parent ) : 
+	IFacePoserToolWindow( "PhonemeEditor", "Phoneme Editor" ), 
+	mxWindow( parent, 0, 0, 0, 0 )
+{
+	SetAutoProcess( false );
+
+	m_flPlaybackRate	= 1.0f;
+
+	m_flScrub			= 0.0f;
+	m_flScrubTarget		= 0.0f;
+
+	m_CurrentMode = MODE_PHONEMES;
+	Emphasis_Init();
+	SetupPhonemeEditorColors();
+
+	m_bRedoPending = false;
+	m_nUndoLevel = 0;
+
+	m_bWordsActive = false;
+
+	m_pWaveFile = NULL;
+	m_pMixer	= NULL;
+	m_pEvent	= NULL;
+	m_nClickX = 0;
+
+	m_WorkFile.m_bDirty = false;
+	m_WorkFile.m_szWaveFile[ 0 ] = 0;
+	m_WorkFile.m_szWorkingFile[ 0 ] = 0;
+	m_WorkFile.m_szBasePath[ 0 ] = 0;
+
+	m_nTickHeight = 20;
+
+	m_flPixelsPerSecond = 500.0f;
+	m_nTimeZoom = 100;
+	m_nTimeZoomStep = TIME_ZOOM_STEP;
+
+	m_pHorzScrollBar = new mxScrollbar( this, 0, 0, 18, 100, IDC_PHONEME_SCROLL, mxScrollbar::Horizontal );
+
+
+	m_hPrevCursor		= 0;
+	m_nStartX			= 0;
+	m_nStartY			= 0;
+	m_nLastX			= 0;
+	m_nLastY			= 0;
+	m_nDragType			= DRAGTYPE_NONE;
+
+	SetClickedPhoneme( -1, -1 );
+
+	m_nSelection[ 0 ] = m_nSelection[ 1 ] = 0;
+	m_bSelectionActive = false;
+
+	m_nSelectedPhonemeCount = 0;
+	m_nSelectedWordCount = 0;
+
+	m_btnSave					= new mxButton( this, 0, 0, 16, 16, "Save (Ctrl+S)", IDC_SAVE_LINGUISTIC );
+	m_btnRedoPhonemeExtraction	= new mxButton( this, 38, 14, 80, 16, "Re-extract (Ctrl+R)", IDC_REDO_PHONEMEEXTRACTION );
+
+	m_btnLoad					= new mxButton( this, 0, 0, 0, 0, "Load (Ctrl+O)", IDC_LOADWAVEFILE );
+	m_btnPlay					= new mxButton( this, 0, 0, 16, 16, "Play (Spacebar)", IDC_PLAYBUTTON );
+
+	m_pPlaybackRate				= new mxSlider( this, 0, 0, 16, 16, IDC_PLAYBACKRATE );
+	m_pPlaybackRate->setRange( 0.0, 2.0, 40 );
+	m_pPlaybackRate->setValue( m_flPlaybackRate );
+
+	m_pModeTab					= new CPhonemeModeTab( this, 0, 0, 500, 20, IDC_MODE_TAB );
+	m_pModeTab->Init();
+
+	m_nLastExtractionResult		= SR_RESULT_NORESULT;
+
+	ClearDragLimit();
+
+	SetSuffix( " - Normal" );
+	m_flScrubberTimeOffset = 0.0f;
+
+	LoadPhonemeConverters();
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+void PhonemeEditor::OnDelete()
+{
+	if ( m_pWaveFile )
+	{
+		char fn[ 512 ];
+		Q_snprintf( fn, sizeof( fn ), "%s%s", m_WorkFile.m_szBasePath, m_WorkFile.m_szWorkingFile );
+		filesystem->RemoveFile( fn, "GAME" );
+	}
+
+	delete m_pWaveFile;
+	m_pWaveFile = NULL;
+
+	m_Tags.Reset();
+	m_TagsExt.Reset();
+
+	UnloadPhonemeConverters();
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+// Output : Returns true on success, false on failure.
+//-----------------------------------------------------------------------------
+bool PhonemeEditor::CanClose()
+{
+	if ( !GetDirty() )
+		return true;
+
+	int retval = mxMessageBox( this, va( "Save current changes to %s", m_WorkFile.m_szWaveFile ),
+		"Phoneme Editor", MX_MB_QUESTION | MX_MB_YESNOCANCEL );
+
+	// Cancel
+	if ( retval == 2 )
+	{
+		return false;
+	}
+
+	// Yes
+	if ( retval == 0 )
+	{
+		CommitChanges();
+	}
+
+	return true;
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+PhonemeEditor::~PhonemeEditor( void )
+{
+}
+
+void PhonemeEditor::SetupPhonemeEditorColors( void )
+{
+	int i;
+	for ( i = 0; i < NUM_COLORS; i++ )
+	{
+		PhonemeEditorColor *p = &g_PEColors[ i ];
+		Assert( p->color_number == i );
+
+		if ( p->mode_number == -1 )
+		{
+			p->gray_color = p->root_color;
+		}
+		else
+		{
+			COLORREF bgColor = g_PEColors[ COLOR_PHONEME_BACKGROUND ].root_color;
+
+			int bgr, bgg, bgb;
+
+			bgr = GetRValue( bgColor );
+			bgg = GetGValue( bgColor );
+			bgb = GetBValue( bgColor );
+			
+			int r, g, b;
+
+			r = GetRValue( p->root_color );
+			g = GetGValue( p->root_color );
+			b = GetBValue( p->root_color );
+
+			int avg = ( r + g + b ) / 3;
+			int bgavg = ( bgr + bgg + bgb ) / 3;
+
+			// Bias toward bg color
+			avg += ( bgavg - avg ) / 2.5;
+
+			p->gray_color = RGB( avg, avg, avg );
+		}
+	}
+}
+
+COLORREF PhonemeEditor::PEColor( int colornum )
+{
+	COLORREF clr = RGB( 0, 0, 0 );
+	if ( colornum < 0 || colornum >= NUM_COLORS )
+	{
+		Assert( 0 );
+		return clr;
+	}
+
+	PhonemeEditorColor *p = &g_PEColors[ colornum ];
+
+	if ( p->mode_number == -1 )
+	{
+		return p->root_color;
+	}
+
+	int modenum = (int)GetMode();
+
+	if ( p->mode_number == modenum )
+	{
+		return p->root_color;
+	}
+	
+	return p->gray_color;
+}
+
+void PhonemeEditor::EditWord( CWordTag *pWord, bool positionDialog /*= false*/ )
+{
+	if ( !pWord )
+	{
+		Con_Printf( "PhonemeEditor::EditWord:  pWord == NULL\n" );
+		return;
+	}
+
+	CInputParams params;
+	memset( &params, 0, sizeof( params ) );
+	strcpy( params.m_szDialogTitle, "Edit Word" );
+	strcpy( params.m_szPrompt, "Current Word:" );
+	V_strcpy_safe( params.m_szInputText, pWord->GetWord() );
+
+	params.m_nLeft = -1;
+	params.m_nTop = -1;
+
+	params.m_bPositionDialog = positionDialog;
+	if ( params.m_bPositionDialog )
+	{
+		RECT rcWord;
+		GetWordRect( pWord, rcWord );
+
+		// Convert to screen coords
+		POINT pt;
+		pt.x = rcWord.left;
+		pt.y = rcWord.top;
+
+		ClientToScreen( (HWND)getHandle(), &pt );
+
+		params.m_nLeft	= pt.x;
+		params.m_nTop	= pt.y;
+	}
+
+	int iret = InputProperties( &params );
+	SetFocus( (HWND)getHandle() );
+	if ( !iret )
+	{
+		return;
+	}
+
+	// Validate parameters
+	if ( CSentence::CountWords( params.m_szInputText ) != 1 )
+	{
+		Con_ErrorPrintf( "Edit word:  %s has multiple words in it!!!\n", params.m_szInputText );
+		return;
+	}
+
+	SetFocus( (HWND)getHandle() );
+
+	SetDirty( true );
+
+	PushUndo();
+
+	// Set the word and clear out the phonemes
+	// ->m_nPhonemeCode = TextToPhoneme( params.m_szName );
+	pWord->SetWord( params.m_szInputText );
+
+	PushRedo();
+
+	redraw();
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+// Input  : *pPhoneme - 
+//			positionDialog - 
+//-----------------------------------------------------------------------------
+void PhonemeEditor::EditPhoneme( CPhonemeTag *pPhoneme, bool positionDialog /*= false*/ )
+{
+	if ( !pPhoneme )
+	{
+		Con_Printf( "PhonemeEditor::EditPhoneme:  pPhoneme == NULL\n" );
+		return;
+	}
+
+	CPhonemeParams params;
+	memset( &params, 0, sizeof( params ) );
+	strcpy( params.m_szDialogTitle, "Phoneme/Viseme Properties" );
+	V_strcpy_safe( params.m_szName, ConvertPhoneme( pPhoneme->GetPhonemeCode() ) );
+
+	params.m_nLeft = -1;
+	params.m_nTop = -1;
+
+	params.m_bPositionDialog = positionDialog;
+	if ( params.m_bPositionDialog )
+	{
+		RECT rcPhoneme;
+		GetPhonemeRect( pPhoneme, rcPhoneme );
+
+		// Convert to screen coords
+		POINT pt;
+		pt.x = rcPhoneme.left;
+		pt.y = rcPhoneme.top;
+
+		ClientToScreen( (HWND)getHandle(), &pt );
+
+		params.m_nLeft	= pt.x;
+		params.m_nTop	= pt.y;
+	}
+
+	int iret = PhonemeProperties( &params );
+	SetFocus( (HWND)getHandle() );
+
+	if ( !iret )
+	{
+		return;
+	}
+
+	SetDirty( true );
+
+	PushUndo();
+
+	pPhoneme->SetPhonemeCode( TextToPhoneme( params.m_szName ) );
+
+	PushRedo();
+
+	redraw();
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+void PhonemeEditor::EditPhoneme( void )
+{
+	if ( GetMode() != MODE_PHONEMES )
+		return;
+
+	CPhonemeTag *pPhoneme = GetClickedPhoneme();
+	if ( !pPhoneme )
+		return;
+
+	EditPhoneme( pPhoneme, false );
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+void PhonemeEditor::EditWord( void )
+{
+	if ( GetMode() != MODE_PHONEMES )
+		return;
+
+	CWordTag *pWord = GetClickedWord();
+	if ( !pWord )
+		return;
+
+	EditWord( pWord, false );
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+// Input  : dragtype - 
+//			startx - 
+//			cursor - 
+//-----------------------------------------------------------------------------
+void PhonemeEditor::StartDragging( int dragtype, int startx, int starty, HCURSOR cursor )
+{
+	m_nDragType = dragtype;
+	m_nStartX	= startx;
+	m_nLastX	= startx;
+	m_nStartY	= starty;
+	m_nLastY	= starty;
+	
+	if ( m_hPrevCursor )
+	{
+		SetCursor( m_hPrevCursor );
+		m_hPrevCursor = NULL;
+	}
+	m_hPrevCursor = SetCursor( cursor );
+
+	m_FocusRects.Purge();
+
+	RECT rc;
+	GetWorkspaceRect( rc );
+
+	RECT rcStart;
+	rcStart.left = startx;
+	rcStart.right = startx;
+
+	bool addrect = true;
+	switch ( dragtype )
+	{
+	default:
+	case DRAGTYPE_SCRUBBER:
+		{
+			RECT rcScrub;
+			GetScrubHandleRect( rcScrub, true );
+
+			rcStart = rcScrub;
+			rcStart.left = ( rcScrub.left + rcScrub.right ) / 2;
+			rcStart.right = rcStart.left;
+			rcStart.bottom = h2() - 18 - MODE_TAB_OFFSET;
+		}
+		break;
+	case DRAGTYPE_EMPHASIS_SELECT:
+		{
+			RECT rcEmphasis;
+			Emphasis_GetRect( rc, rcEmphasis );
+
+			rcStart.top = starty;
+			rcStart.bottom = starty;
+		}
+		break;
+	case DRAGTYPE_EMPHASIS_MOVE:
+		{
+			SetDirty( true );
+
+			PushUndo();
+
+			Emphasis_MouseDrag( startx, starty );
+			m_Tags.Resort();
+
+			addrect = false;
+		}
+		break;
+	case DRAGTYPE_SELECTSAMPLES:
+	case DRAGTYPE_MOVESELECTIONSTART:
+	case DRAGTYPE_MOVESELECTIONEND:
+		rcStart.top = rc.top;
+		rcStart.bottom = rc.bottom;
+		break;
+	case DRAGTYPE_MOVESELECTION:
+		{
+			rcStart.top = rc.top;
+			rcStart.bottom = rc.bottom;
+
+			// Compute left/right pixels for selection
+			rcStart.left = GetPixelForSample( m_nSelection[ 0 ] );
+			rcStart.right = GetPixelForSample( m_nSelection[ 1 ] );
+		}
+		break;
+	case DRAGTYPE_PHONEME:
+		{
+			GetPhonemeTrayTopBottom( rcStart );
+			m_bWordsActive = false;
+		}
+		break;
+	case DRAGTYPE_WORD:
+		{
+			GetWordTrayTopBottom( rcStart );
+			m_bWordsActive = true;
+		}
+		break;
+	case DRAGTYPE_MOVEWORD:
+		{
+			TraverseWords( &PhonemeEditor::ITER_AddFocusRectSelectedWords, 0.0f );
+			addrect = false;
+			m_bWordsActive = true;
+		}
+		break;
+	case DRAGTYPE_MOVEPHONEME:
+		{
+			TraversePhonemes( &PhonemeEditor::ITER_AddFocusRectSelectedPhonemes, 0.0f );
+			addrect = false;
+			m_bWordsActive = false;
+		}
+		break;
+	case DRAGTYPE_EVENTTAG_MOVE:
+		{
+			rcStart.top = TAG_TOP;
+			rcStart.bottom = TAG_BOTTOM;
+			rcStart.left -= 10;
+			rcStart.right += 10;
+		}
+		break;
+	}
+
+	if ( addrect )
+	{
+		AddFocusRect( rcStart );
+	}
+	
+	DrawFocusRect( "start" );
+
+	SetDragLimit( m_nDragType );
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+// Input  : *event - 
+// Output : int
+//-----------------------------------------------------------------------------
+int PhonemeEditor::handleEvent( mxEvent *event )
+{
+	MDLCACHE_CRITICAL_SECTION_( g_pMDLCache );
+
+	int iret = 0;
+	
+	if ( HandleToolEvent( event ) )
+	{
+		return iret;
+	}
+
+	switch ( event->event )
+	{
+	case mxEvent::Action:
+		{
+			iret = 1;
+			switch ( event->action )
+			{
+			case IDC_EXPORT_SENTENCE:
+				{
+					OnExport();
+				}
+				break;
+			case IDC_IMPORT_SENTENCE:
+				{
+					OnImport();
+				}
+				break;
+			case IDC_PLAYBACKRATE:
+				{
+					m_flPlaybackRate = m_pPlaybackRate->getValue();
+					redraw();
+				}
+				break;
+			case IDC_MODE_TAB:
+				{
+					// The mode changed, so reset stuff here
+					EditorMode newMode = (EditorMode)m_pModeTab->getSelectedIndex();
+					bool needpaint = ( m_CurrentMode != newMode );
+					m_CurrentMode = newMode;
+					if ( needpaint )
+					{
+						switch ( GetMode() )
+						{
+						default:
+						case MODE_PHONEMES:
+							SetSuffix( " - Normal" );
+							break;
+						case MODE_EMPHASIS:
+							SetSuffix( " - Emphasis Track" );
+							break;
+						}
+
+						OnModeChanged();
+						redraw();
+					}
+				}
+				break;
+			case IDC_EMPHASIS_DELETE:
+				Emphasis_Delete();
+				break;
+			case IDC_EMPHASIS_DESELECT:
+				Emphasis_DeselectAll();
+				break;
+			case IDC_EMPHASIS_SELECTALL:
+				Emphasis_SelectAll();
+				break;
+			case IDC_API_SAPI:
+				OnSAPI();
+				break;
+			case IDC_API_LIPSINC:
+				OnLipSinc();
+				break;
+			case IDC_PLAYBUTTON:
+				Play();
+				break;
+			case IDC_UNDO:
+				Undo();
+				break;
+			case IDC_REDO:
+				Redo();
+				break;
+			case IDC_CLEARUNDO:
+				ClearUndo();
+				break;
+			case IDC_ADDTAG:
+				AddTag();
+				break;
+			case IDC_DELETETAG:
+				DeleteTag();
+				break;
+			case IDC_COMMITEXTRACTED:
+				CommitExtracted();
+				SetFocus( (HWND)getHandle() );
+				break;
+			case IDC_CLEAREXTRACTED:
+				ClearExtracted();
+				break;
+			case IDC_SEPARATEPHONEMES:
+				SeparatePhonemes();
+				break;
+			case IDC_SNAPPHONEMES:
+				SnapPhonemes();
+				break;
+			case IDC_SEPARATEWORDS:
+				SeparateWords();
+				break;
+			case IDC_SNAPWORDS:
+				SnapWords();
+				break;
+			case IDC_EDITWORDLIST:
+				EditWordList();
+				break;
+			case IDC_EDIT_PHONEME:
+				EditPhoneme();
+				break;
+			case IDC_EDIT_WORD:
+				EditWord();
+				break;
+			case IDC_EDIT_INSERTPHONEMEBEFORE:
+				EditInsertPhonemeBefore();
+				break;
+			case IDC_EDIT_INSERTPHONEMEAFTER:
+				EditInsertPhonemeAfter();
+				break;
+			case IDC_EDIT_INSERTWORDBEFORE:
+				EditInsertWordBefore();
+				break;
+			case IDC_EDIT_INSERTWORDAFTER:
+				EditInsertWordAfter();
+				break;
+			case IDC_EDIT_DELETEPHONEME:
+				EditDeletePhoneme();
+				break;
+			case IDC_EDIT_DELETEWORD:
+				EditDeleteWord();
+				break;
+			case IDC_EDIT_INSERTFIRSTPHONEMEOFWORD:
+				EditInsertFirstPhonemeOfWord();
+				break;
+			case IDC_PHONEME_PLAY_ORIG:
+				{
+					StopPlayback();
+					if ( m_pWaveFile )
+					{
+						// Make sure phonemes are loaded
+						FacePoser_EnsurePhonemesLoaded();
+
+						sound->PlaySound( m_pWaveFile, VOL_NORM, &m_pMixer );
+					}
+				}
+				break;
+			case IDC_PHONEME_SCROLL:
+				if (event->modifiers == SB_THUMBTRACK)
+				{
+					MoveTimeSliderToPos( event->height );
+				}
+				else if ( event->modifiers == SB_PAGEUP )
+				{
+					int offset = m_pHorzScrollBar->getValue();
+					
+					offset -= 10;
+					offset = max( offset, m_pHorzScrollBar->getMinValue() );
+
+					MoveTimeSliderToPos( offset );
+				}
+				else if ( event->modifiers == SB_PAGEDOWN )
+				{
+					int offset = m_pHorzScrollBar->getValue();
+					
+					offset += 10;
+					offset = min( offset, m_pHorzScrollBar->getMaxValue() );
+
+					MoveTimeSliderToPos( offset );
+				}
+				break;	
+			case IDC_REDO_PHONEMEEXTRACTION:
+				if ( m_Tags.m_Words.Size() <= 0 )
+				{
+					// This calls redo LISET if some words are actually entered
+					EditWordList();
+				}
+				else
+				{
+					RedoPhonemeExtraction();
+				}
+				SetFocus( (HWND)getHandle() );
+				break;
+			case IDC_REDO_PHONEMEEXTRACTION_SELECTION:
+				{
+					RedoPhonemeExtractionSelected();
+				}
+				SetFocus( (HWND)getHandle() );
+				break;
+			case IDC_DESELECT:
+				Deselect();
+				redraw();
+				break;
+			case IDC_PLAY_EDITED:
+				PlayEditedWave( false );
+				SetFocus( (HWND)getHandle() );
+				break;
+			case IDC_PLAY_EDITED_SELECTION:
+				PlayEditedWave( true );
+				SetFocus( (HWND)getHandle() );
+				break;
+			case IDC_SAVE_LINGUISTIC:
+				CommitChanges();
+				SetFocus( (HWND)getHandle() );
+				break;
+			case IDC_LOADWAVEFILE:
+				LoadWaveFile();
+				SetFocus( (HWND)getHandle() );
+				break;
+			case IDC_CANCELPLAYBACK:
+				StopPlayback();
+				SetFocus( (HWND)getHandle() );
+				break;
+			case IDC_SELECT_WORDSRIGHT:
+				SelectWords( true );
+				break;
+			case IDC_SELECT_WORDSLEFT:
+				SelectWords( false );
+				break;
+			case IDC_SELECT_PHONEMESRIGHT:
+				SelectPhonemes( true );
+				break;
+			case IDC_SELECT_PHONEMESLEFT:
+				SelectPhonemes( false );
+				break;
+			case IDC_DESELECT_PHONEMESANDWORDS:
+				DeselectPhonemes();
+				DeselectWords();
+				redraw();
+				break;
+			case IDC_CLEANUP:
+				CleanupWordsAndPhonemes( true );
+				redraw();
+				break;
+			case IDC_REALIGNPHONEMES:
+				RealignPhonemesToWords( true );
+				redraw();
+				break;
+			case IDC_REALIGNWORDS:
+				RealignWordsToPhonemes( true );
+				redraw();
+				break;
+			case IDC_TOGGLE_VOICEDUCK:
+				OnToggleVoiceDuck();
+				break;
+			}
+
+			if ( iret == 1 )
+			{
+				SetActiveTool( this );
+				SetFocus( (HWND)getHandle() );
+			}
+		}
+		break;
+	case mxEvent::MouseWheeled:
+		{
+			// Zoom time in  / out
+			if ( event->height > 0 )
+			{
+				m_nTimeZoom = min( m_nTimeZoom + m_nTimeZoomStep, MAX_TIME_ZOOM );
+			}
+			else
+			{
+				m_nTimeZoom = max( m_nTimeZoom - m_nTimeZoomStep, m_nTimeZoomStep );
+			}
+			RepositionHSlider();
+			iret = 1;
+		}
+		break;
+	case mxEvent::Size:
+		{
+			int bw	= 100;
+			int x	= 5;
+			int by = h2() - 18 - MODE_TAB_OFFSET;
+
+			m_pModeTab->setBounds( 0, h2() - MODE_TAB_OFFSET, w2(), MODE_TAB_OFFSET );
+
+			m_btnRedoPhonemeExtraction->setBounds( x, by, bw, 16 );
+			x += bw;
+			m_btnSave->setBounds( x, by, bw, 16 );
+			x += bw;
+			m_btnLoad->setBounds( x, by, bw, 16 );
+			x += bw;
+			m_btnPlay->setBounds( x, by, bw, 16 );
+			x += bw;
+
+			m_pPlaybackRate->setBounds( x, by, 100, 16 );
+
+			RepositionHSlider();
+			iret = 1;
+		}
+		break;
+	case mxEvent::MouseDown:
+		{
+			iret = 1;
+
+			CPhonemeTag *pt;
+			CWordTag *wt;
+			
+			pt = GetPhonemeTagUnderMouse( (short)event->x, (short)event->y );
+			wt = GetWordTagUnderMouse( (short)event->x, (short)event->y );
+
+			bool ctrldown = ( event->modifiers & mxEvent::KeyCtrl ) ? true : false;
+			bool shiftdown = ( event->modifiers & mxEvent::KeyShift ) ? true : false;
+			
+			if ( event->buttons & mxEvent::MouseRightButton )
+			{
+				RECT rc;
+				GetWorkspaceRect( rc );
+
+				if ( IsMouseOverWordRow( (short)event->y ) )
+				{
+					ShowWordMenu( wt,  (short)event->x, (short)event->y );
+				}
+				else if ( IsMouseOverPhonemeRow( (short)event->y ) )
+				{
+					ShowPhonemeMenu( pt, (short)event->x, (short)event->y );
+				}
+				else if ( IsMouseOverTagRow( (short)event->y ) )
+				{
+					ShowTagMenu( (short)event->x, (short)event->y );
+				}
+				else if ( IsMouseOverScrubArea( event ) )
+				{
+					float t = GetTimeForPixel( (short)event->x );
+
+					ClampTimeToSelectionInterval( t );
+
+					SetScrubTime( t );
+					SetScrubTargetTime( t );
+
+					redraw();
+				}
+				else
+				{
+					ShowContextMenu( (short)event->x, (short)event->y );
+				}
+				return iret;
+			}
+			
+			if ( m_nDragType == DRAGTYPE_NONE )
+			{
+				CountSelected();
+
+				int type = IsMouseOverBoundary( event );
+
+				if ( IsMouseOverScrubArea( event ) )
+				{
+					if ( IsMouseOverScrubHandle( event ) )
+					{
+						StartDragging( DRAGTYPE_SCRUBBER, 
+							(short)event->x, 
+							(short)event->y, 
+							LoadCursor( NULL, IDC_SIZEWE ) );
+
+						float t = GetTimeForPixel( (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 );
+
+						DrawScrubHandle();
+						iret = true;
+					}
+					else
+					{
+						float t = GetTimeForPixel( (short)event->x );
+
+						ClampTimeToSelectionInterval( t );
+
+						SetScrubTargetTime( t );
+
+						iret = true;
+
+					}
+					return iret;
+				}
+				else if ( GetMode() == MODE_EMPHASIS )
+				{
+					CEmphasisSample *sample = Emphasis_GetSampleUnderMouse( event );
+					if ( sample )
+					{
+						if  ( shiftdown ) 
+						{
+							sample->selected = !sample->selected;
+							redraw();
+						}
+						else if ( sample->selected )
+						{
+							StartDragging( DRAGTYPE_EMPHASIS_MOVE, (short)event->x, (short)event->y, LoadCursor( NULL, IDC_SIZEALL ) );
+						}
+						else
+						{
+							if  ( !shiftdown ) 
+							{
+								Emphasis_DeselectAll();
+								redraw();
+							}
+
+							StartDragging( DRAGTYPE_EMPHASIS_SELECT, (short)event->x, (short)event->y, NULL );
+						}
+						return true;
+					}
+					else if ( ctrldown )
+					{
+						// Add a sample point
+						float t = GetTimeForPixel( (short)event->x );
+
+						RECT rcWork;
+						GetWorkspaceRect( rcWork );
+						RECT rcEmphasis;
+						Emphasis_GetRect( rcWork, rcEmphasis );
+
+						int eh = rcEmphasis.bottom - rcEmphasis.top;
+						int dy = (short)event->y - rcEmphasis.top;
+
+						CEmphasisSample sample;
+						sample.time = t;
+						Assert( eh >= 0 );
+						sample.value = (float)( dy ) / ( float ) eh;
+						sample.value = 1.0f - clamp( sample.value, 0.0f, 1.0f );
+						sample.selected = false;
+
+						Emphasis_AddSample( sample );
+
+						redraw();
+
+						return true;
+					}
+					else
+					{
+						if  ( !shiftdown ) 
+						{
+							Emphasis_DeselectAll();
+							redraw();
+						}
+
+						StartDragging( DRAGTYPE_EMPHASIS_SELECT, (short)event->x, (short)event->y, NULL );
+						return true;
+					}
+				}
+				else
+				{
+					if ( type == BOUNDARY_PHONEME && m_nSelectedPhonemeCount <= 1 )
+					{
+						StartDragging( DRAGTYPE_PHONEME, (short)event->x, (short)event->y, LoadCursor( NULL, IDC_SIZEWE ) );
+						return true;
+					}			
+					else if ( type == BOUNDARY_WORD && m_nSelectedWordCount <= 1 )
+					{
+						StartDragging( DRAGTYPE_WORD, (short)event->x, (short)event->y, LoadCursor( NULL, IDC_SIZEWE ) );
+						return true;
+					}
+					else if ( IsMouseOverSamples( (short)event->x, (short)event->y ) )
+					{
+						if ( !m_bSelectionActive )
+						{
+							StartDragging( DRAGTYPE_SELECTSAMPLES, (short)event->x, (short)event->y, LoadCursor( NULL, IDC_SIZEWE ) );
+						}
+						else
+						{
+							// Either move, move edge if ctrl key is held, or deselect
+							if ( IsMouseOverSelection( (short)event->x, (short)event->y ) )
+							{
+								if ( IsMouseOverSelectionStartEdge( event ) )
+								{
+									StartDragging( DRAGTYPE_MOVESELECTIONSTART, (short)event->x, (short)event->y, LoadCursor( NULL, IDC_SIZEWE ) );
+								}
+								else if ( IsMouseOverSelectionEndEdge( event ) )
+								{
+									StartDragging( DRAGTYPE_MOVESELECTIONEND, (short)event->x, (short)event->y, LoadCursor( NULL, IDC_SIZEWE ) );
+								}
+								else
+								{
+									if ( shiftdown )
+									{
+										StartDragging( DRAGTYPE_MOVESELECTION, (short)event->x, (short)event->y, LoadCursor( NULL, IDC_SIZEALL ) );
+									}
+								}
+							}
+							else
+							{
+								Deselect();
+								redraw();
+								return iret;
+							}
+						}
+						return true;
+					}
+				}
+				
+				if ( IsMouseOverTag( (short)event->x, (short)event->y ) )
+				{
+					StartDragging( DRAGTYPE_EVENTTAG_MOVE, (short)event->x, (short)event->y, LoadCursor( NULL, IDC_SIZEALL ) );
+					return true;
+				}
+				else
+				{
+					if ( pt )
+					{
+						// Can only move when holding down shift key
+						if ( shiftdown )
+						{
+							pt->m_bSelected = true;
+							StartDragging( DRAGTYPE_MOVEPHONEME,
+								(short)event->x, (short)event->y, LoadCursor( NULL, IDC_SIZEALL ) );
+						}
+						else
+						{
+							// toggle the selection
+							pt->m_bSelected = !pt->m_bSelected;
+						}
+
+
+						m_bWordsActive = false;
+
+						redraw();
+						return true;
+					}
+					else if ( wt )
+					{
+
+						// Can only move when holding down shift key
+						if ( shiftdown )
+						{
+							wt->m_bSelected = true;
+							StartDragging( DRAGTYPE_MOVEWORD,
+								(short)event->x, (short)event->y, LoadCursor( NULL, IDC_SIZEALL ) );
+						}
+						else
+						{
+							// toggle the selection
+							wt->m_bSelected = !wt->m_bSelected;
+						}
+
+						m_bWordsActive = true;
+
+						redraw();
+						return true;
+					}
+					else if ( type == BOUNDARY_NONE )
+					{
+						DeselectPhonemes();
+						DeselectWords();
+						redraw();
+						return true;
+					}
+				}
+			}
+		}
+		break;
+	case mxEvent::MouseMove:
+	case mxEvent::MouseDrag:
+		{
+			OnMouseMove( event );
+			iret = 1;
+		}
+		break;
+	case mxEvent::MouseUp:
+		{
+			if ( m_nDragType != DRAGTYPE_NONE )
+			{
+				int mx = (short)event->x;
+
+				LimitDrag( mx );
+
+				event->x = (short)mx;
+
+				DrawFocusRect( "finish" );
+
+				if ( m_hPrevCursor )
+				{
+					SetCursor( m_hPrevCursor );
+					m_hPrevCursor = 0;
+				}
+
+				switch ( m_nDragType )
+				{
+				case DRAGTYPE_WORD:
+					FinishWordMove( m_nStartX, (short)event->x );
+					break;
+				case DRAGTYPE_PHONEME:
+					FinishPhonemeMove( m_nStartX, (short)event->x );
+					break;
+				case DRAGTYPE_SELECTSAMPLES:
+					FinishSelect( m_nStartX, (short)event->x );
+					break;
+				case DRAGTYPE_MOVESELECTION:
+					FinishMoveSelection( m_nStartX, (short)event->x );
+					break;
+				case DRAGTYPE_MOVESELECTIONSTART:
+					FinishMoveSelectionStart( m_nStartX, (short)event->x );
+					break;
+				case DRAGTYPE_MOVESELECTIONEND:
+					FinishMoveSelectionEnd( m_nStartX, (short)event->x );
+					break;
+				case DRAGTYPE_MOVEWORD:
+					FinishWordDrag( m_nStartX, (short)event->x );
+					break;
+				case DRAGTYPE_MOVEPHONEME:
+					FinishPhonemeDrag( m_nStartX, (short)event->x );
+					break;
+				case DRAGTYPE_EVENTTAG_MOVE:
+					FinishEventTagDrag( m_nStartX, (short)event->x );
+					break;
+				case DRAGTYPE_EMPHASIS_MOVE:
+					{
+						Emphasis_MouseDrag( (short)event->x, (short)event->y );
+						m_Tags.Resort();
+
+						PushRedo();
+
+						redraw();
+					}
+					break;
+				case DRAGTYPE_EMPHASIS_SELECT:
+					{
+						Emphasis_SelectPoints();
+						redraw();
+					}
+					break;
+				case DRAGTYPE_SCRUBBER:
+					{
+						float t = GetTimeForPixel( (short)event->x );
+						t += m_flScrubberTimeOffset;
+						m_flScrubberTimeOffset = 0.0f;
+
+						ClampTimeToSelectionInterval( t );
+
+						SetScrubTime( t );
+						SetScrubTargetTime( t );
+
+						sound->Flush(); 
+
+						DrawScrubHandle();
+					}
+					break;
+				default:
+					break;
+				}
+
+				m_nDragType = DRAGTYPE_NONE;
+			}
+			iret = 1;
+		}
+		break;
+	case mxEvent::KeyUp:
+		{
+			bool shiftDown = GetAsyncKeyState( VK_SHIFT ) ? true : false;
+			bool ctrlDown = GetAsyncKeyState( VK_CONTROL ) ? true : false;
+
+			switch( event->key )
+			{
+				case VK_TAB:
+					{
+						int direction = shiftDown ? -1 : 1;
+						SelectNextWord( direction );
+					}
+					break;
+				case VK_NEXT:
+				case VK_PRIOR:
+					{
+						m_bWordsActive = event->key == VK_PRIOR ? true : false;
+						redraw();
+					}
+					break;
+				case VK_UP:
+				case VK_RETURN:
+					if ( m_bWordsActive )
+					{
+						if ( event->key == VK_UP ||
+							ctrlDown )
+						{
+							CountSelected();
+
+							if ( m_nSelectedWordCount == 1 )
+							{
+								// Find the selected one
+								for ( int i = 0; i < m_Tags.m_Words.Size(); i++ )
+								{
+									CWordTag *word = m_Tags.m_Words[ i ];
+									if ( !word || !word->m_bSelected )
+										continue;
+
+									EditWord( word, true );
+								}
+							}
+						}
+					}
+					else
+					{
+						if ( event->key == VK_UP ||
+							ctrlDown )
+						{
+							CountSelected();
+
+							if ( m_nSelectedPhonemeCount == 1 )
+							{
+								// Find the selected one
+								for ( int i = 0; i < m_Tags.m_Words.Size(); i++ )
+								{
+									CWordTag *word = m_Tags.m_Words[ i ];
+									if ( !word )
+										continue;
+
+									for ( int j = 0; j < word->m_Phonemes.Size(); j++ )
+									{
+										CPhonemeTag *phoneme = word->m_Phonemes[ j ];
+										if ( !phoneme )
+											continue;
+
+										if ( !phoneme->m_bSelected )
+											continue;
+								
+										EditPhoneme( phoneme, true );
+									}
+								}
+							}
+						}
+					}
+					break;
+				case VK_DELETE:
+					if ( GetMode() == MODE_EMPHASIS )
+					{
+						Emphasis_Delete();
+					}
+					else
+					{
+						if ( m_bWordsActive )
+						{
+							EditDeleteWord();
+						}
+						else
+						{
+							EditDeletePhoneme();
+						}
+					}
+					break;
+				case VK_INSERT:
+					if ( m_bWordsActive )
+					{
+						if ( shiftDown )
+						{
+							EditInsertWordBefore();
+						}
+						else
+						{
+							EditInsertWordAfter();
+						}
+					}
+					else
+					{
+						if ( shiftDown )
+						{
+							EditInsertPhonemeBefore();
+						}
+						else
+						{
+							EditInsertPhonemeAfter();
+						}
+					}
+					break;
+				case VK_SPACE:
+					if ( m_pWaveFile && sound->IsSoundPlaying( m_pMixer ) )
+					{
+						Con_Printf( "Stopping playback\n" );
+						m_btnPlay->setLabel( "Play (Spacebar)" );
+						StopPlayback();	
+					}
+					else
+					{
+						Con_Printf( "Playing .wav\n" );
+						m_btnPlay->setLabel( "Stop[ (Spacebar)" );
+						PlayEditedWave( m_bSelectionActive );
+					}
+					break;
+				case VK_SHIFT:
+				case VK_CONTROL:
+					{
+						// Force mouse move
+						POINT pt;
+						GetCursorPos( &pt );
+						SetCursorPos( pt.x, pt.y );
+						return 0;
+					}
+					break;
+				case VK_ESCAPE:
+					{
+						// If playing sound, stop it, otherwise, deselect all
+						if ( !StopPlayback() )
+						{
+							Deselect();
+							DeselectPhonemes();
+							DeselectWords();
+							Emphasis_DeselectAll();
+							redraw();
+						}
+					}
+					break;
+				case 'O':
+					{
+						if ( ctrlDown )
+						{
+							LoadWaveFile();
+						}
+					}
+					break;
+				case 'S':
+					{
+						if ( ctrlDown )
+						{
+							CommitChanges();
+						}
+					}
+					break;
+				case 'T':
+					{
+						if ( ctrlDown )
+						{
+							// Edit sentence text
+							EditWordList();
+						}
+					}
+					break;
+				case 'G':
+					{
+						if ( ctrlDown )
+						{
+							// Commit extraction
+							CommitExtracted();
+						}
+					}
+					break;
+				case 'R':
+					{
+						if ( ctrlDown )
+						{
+							RedoPhonemeExtraction();
+						}
+					}
+					break;
+				default:
+					break;
+			}
+
+			SetFocus( (HWND)getHandle() );
+			iret = 1;
+		}
+		break;
+	case mxEvent::KeyDown:
+		{
+			switch ( event->key )
+			{
+			case 'Z':
+				if ( GetAsyncKeyState( VK_CONTROL ) )
+				{
+					Undo();
+				}
+				break;
+			case 'Y':
+				if ( GetAsyncKeyState( VK_CONTROL ) )
+				{
+					Redo();
+				}
+				break;
+
+
+			case VK_RIGHT:
+			case VK_LEFT:
+				{
+					int direction = event->key == VK_LEFT ? -1 : 1;
+
+					if ( !m_bWordsActive )
+					{
+						if ( GetAsyncKeyState( VK_CONTROL ) )
+						{
+							ExtendSelectedPhonemeEndTime( direction );
+						}
+						else if ( GetAsyncKeyState( VK_SHIFT ) )
+						{
+							ShiftSelectedPhoneme( direction );
+						}
+						else
+						{
+							SelectNextPhoneme( direction );
+						}
+					}
+					else
+					{
+						if ( GetAsyncKeyState( VK_CONTROL ) )
+						{
+							ExtendSelectedWordEndTime( direction );
+						}
+						else if ( GetAsyncKeyState( VK_SHIFT ) )
+						{
+							ShiftSelectedWord( direction );
+						}
+						else
+						{
+							SelectNextWord( direction );
+						}
+					}
+				}
+				break;
+			case VK_RETURN:
+				{
+				}
+				break;
+			case VK_SHIFT:
+			case VK_CONTROL:
+				{
+					// Force mouse move
+					POINT pt;
+					GetCursorPos( &pt );
+					//SetCursorPos( pt.x -1, pt.y );
+					SetCursorPos( pt.x, pt.y );
+					return 0;
+				}
+				break;
+			default:
+				break;
+			}
+			iret = 1;
+		}
+		break;
+	}
+	return iret;
+}
+
+void PhonemeEditor::DrawWords( CChoreoWidgetDrawHelper& drawHelper, RECT& rcWorkSpace, CSentence& sentence, int type, bool showactive /* = true */ )
+{
+	float starttime = m_nLeftOffset / GetPixelsPerSecond();
+	float endtime = w2() / GetPixelsPerSecond() + starttime;
+
+	int ypos = rcWorkSpace.top + m_nTickHeight + 2;
+
+	if ( type == 1 )
+	{
+		ypos += m_nTickHeight + 5;
+	}
+
+	const char *fontName = "Arial";
+
+	bool drawselected;
+	for ( int pass = 0; pass < 2 ; pass++ )
+	{
+		drawselected = pass == 0 ? false : true;
+
+		for (int k = 0; k < sentence.m_Words.Size(); k++)
+		{
+			CWordTag *word = sentence.m_Words[ k ];
+			if ( !word )
+				continue;
+
+			if ( word->m_bSelected != drawselected )
+				continue;
+
+			bool hasselectedphonemes = false;
+			for ( int p = 0; p < word->m_Phonemes.Size() && !hasselectedphonemes; p++ )
+			{
+				CPhonemeTag *t = word->m_Phonemes[ p ];
+				if ( t->m_bSelected )
+				{
+					hasselectedphonemes = true;
+				}
+			}
+
+			float t1 = word->m_flStartTime;
+			float t2 = word->m_flEndTime;
+
+			// Tag it
+			float frac = ( t1 - starttime ) / ( endtime - starttime );
+
+			int xpos = ( int )( frac * rcWorkSpace.right );
+
+			if ( frac <= 0.0 )
+				xpos = 0;
+
+			// Draw duration
+			float frac2  = ( t2 - starttime ) / ( endtime - starttime );
+			if ( frac2 < 0.0 )
+				continue;
+
+			int xpos2 = ( int )( frac2 * rcWorkSpace.right );
+
+			// Draw line and vertical ticks
+			RECT rcWord;
+			rcWord.left = xpos;
+			rcWord.right = xpos2;
+			rcWord.top = ypos - m_nTickHeight + 1;
+			rcWord.bottom = ypos;
+
+			drawHelper.DrawFilledRect( 
+				PEColor( word->m_bSelected ? COLOR_PHONEME_TAG_SELECTED : COLOR_PHONEME_TAG_FILLER_NORMAL ), 
+				rcWord );
+
+			COLORREF border = PEColor( word->m_bSelected ? COLOR_PHONEME_TAG_BORDER_SELECTED : COLOR_PHONEME_TAG_BORDER );
+
+			if ( showactive && m_bWordsActive )
+			{
+				drawHelper.DrawFilledRect( PEColor( COLOR_PHONEME_ACTIVE_BORDER ), xpos, ypos - m_nTickHeight, xpos2, ypos - m_nTickHeight + 4 );
+			}
+
+			drawHelper.DrawColoredLine( border, PS_SOLID, 1, xpos, ypos, xpos2, ypos );
+			drawHelper.DrawColoredLine( border, PS_SOLID, 1, xpos, ypos, xpos, ypos - m_nTickHeight );
+			drawHelper.DrawColoredLine( border, PS_SOLID, 1, xpos2, ypos, xpos2, ypos - m_nTickHeight );
+			drawHelper.DrawColoredLine( border, PS_SOLID, 1, xpos, ypos - m_nTickHeight, xpos2, ypos - m_nTickHeight );
+
+			if ( hasselectedphonemes )
+			{
+				drawHelper.DrawFilledRect( PEColor( COLOR_PHONEME_SELECTED_BORDER ), xpos, ypos - 3, xpos2, ypos );
+			}
+		
+			//if ( frac >= 0.0 && frac <= 1.0 )
+			{
+				int fontsize = 9;
+
+				RECT rcText;
+				rcText.left = xpos;
+				rcText.right = xpos + 500;
+				rcText.top = ypos - m_nTickHeight + 4;
+				rcText.bottom = rcText.top + fontsize + 2;
+
+				int length = drawHelper.CalcTextWidth( fontName, fontsize, FW_NORMAL, "%s", word->GetWord() );
+
+				rcText.right = max( (LONG)xpos2 - 2, rcText.left + length + 1 );
+
+				int w = rcText.right - rcText.left;
+				if ( w > length )
+				{
+					rcText.left += ( w - length ) / 2;
+				}
+
+				drawHelper.DrawColoredText( 
+					fontName, 
+					fontsize, 
+					FW_NORMAL, 
+					PEColor( word->m_bSelected ? COLOR_PHONEME_TAG_TEXT_SELECTED : COLOR_PHONEME_TAG_TEXT ), 
+					rcText,
+					"%s", word->GetWord() );
+			}
+
+		}
+	}
+}
+
+void PhonemeEditor::DrawPhonemes( CChoreoWidgetDrawHelper& drawHelper, RECT& rcWorkSpace, CSentence& sentence, int type, bool showactive /* = true */ )
+{
+	float starttime = m_nLeftOffset / GetPixelsPerSecond();
+	float endtime = w2() / GetPixelsPerSecond() + starttime;
+
+	int ypos = rcWorkSpace.bottom - m_nTickHeight - 2;
+
+	if ( type == 1 )
+	{
+		ypos -= ( m_nTickHeight + 5 );
+	}
+
+	const char *fontName = "Arial";
+
+	bool drawselected;
+	for ( int pass = 0; pass < 2 ; pass++ )
+	{
+		drawselected = pass == 0 ? false : true;
+
+		for ( int i = 0; i < sentence.m_Words.Size(); i++ )
+		{
+			CWordTag *w = sentence.m_Words[ i ];
+			if ( !w )
+				continue;
+
+			if ( w->m_bSelected != drawselected )
+				continue;
+
+			for ( int k = 0; k < w->m_Phonemes.Size(); k++ )
+			{
+				CPhonemeTag *pPhoneme = w->m_Phonemes[ k ];
+
+				float t1 = pPhoneme->GetStartTime();
+				float t2 = pPhoneme->GetEndTime();
+
+				// Tag it
+				float frac = ( t1 - starttime ) / ( endtime - starttime );
+
+				int xpos = ( int )( frac * rcWorkSpace.right );
+				if ( frac <= 0.0 )
+				{
+					xpos = 0;
+				}
+
+				// Draw duration
+				float frac2  = ( t2 - starttime ) / ( endtime - starttime );
+				if ( frac2 < 0.0 )
+				{
+					continue;
+				}
+
+				int xpos2 = ( int )( frac2 * rcWorkSpace.right );
+
+				RECT rcFrame;
+				rcFrame.left = xpos;
+				rcFrame.right = xpos2;
+				rcFrame.top = ypos - m_nTickHeight + 1;
+				rcFrame.bottom = ypos;
+
+				drawHelper.DrawFilledRect( 
+					PEColor( pPhoneme->m_bSelected ? COLOR_PHONEME_TAG_SELECTED : COLOR_PHONEME_TAG_FILLER_NORMAL ),
+					rcFrame );
+
+				COLORREF border = PEColor( pPhoneme->m_bSelected ? COLOR_PHONEME_TAG_BORDER_SELECTED : COLOR_PHONEME_TAG_BORDER );
+
+				if ( showactive && !m_bWordsActive )
+				{
+					drawHelper.DrawFilledRect( PEColor( COLOR_PHONEME_ACTIVE_BORDER ), xpos, ypos - 3, xpos2, ypos );
+				}
+
+				drawHelper.DrawColoredLine( border, PS_SOLID, 1, xpos, ypos - m_nTickHeight, xpos2, ypos - m_nTickHeight );
+				drawHelper.DrawColoredLine( border, PS_SOLID, 1, xpos, ypos, xpos, ypos - m_nTickHeight );
+				drawHelper.DrawColoredLine( border, PS_SOLID, 1, xpos2, ypos, xpos2, ypos - m_nTickHeight );
+				drawHelper.DrawColoredLine( border, PS_SOLID, 1, xpos, ypos, xpos2, ypos );
+
+				if ( w->m_bSelected )
+				{
+					drawHelper.DrawFilledRect( PEColor( COLOR_PHONEME_SELECTED_BORDER ), xpos, ypos - m_nTickHeight + 1, xpos2, ypos - m_nTickHeight + 4 );
+				}
+
+				//if ( frac >= 0.0 && frac <= 1.0 )
+				{
+
+					int fontsize = 9;
+
+					RECT rcText;
+					rcText.left = xpos;
+					rcText.right = xpos + 500;
+					rcText.top = ypos - m_nTickHeight + 4;
+					rcText.bottom = rcText.top + fontsize + 2;
+
+					int length = drawHelper.CalcTextWidth( fontName, fontsize, FW_NORMAL, "%s", ConvertPhoneme( pPhoneme->GetPhonemeCode() ) );
+
+					rcText.right = max( (LONG)xpos2 - 2, rcText.left + length + 1 );
+
+					int w = rcText.right - rcText.left;
+					if ( w > length )
+					{
+						rcText.left += ( w - length ) / 2;
+					}
+
+					drawHelper.DrawColoredText( 
+						fontName, 
+						fontsize, 
+						FW_NORMAL, 
+						PEColor( pPhoneme->m_bSelected ? COLOR_PHONEME_TAG_TEXT_SELECTED : COLOR_PHONEME_TAG_TEXT ), 
+						rcText,
+						"%s", ConvertPhoneme( pPhoneme->GetPhonemeCode() ) );
+				}
+			}
+		}
+	}
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+// Input  : drawHelper - 
+//			rc - 
+//-----------------------------------------------------------------------------
+void PhonemeEditor::DrawRelativeTags( CChoreoWidgetDrawHelper& drawHelper, RECT& rc )
+{
+	if ( !m_pEvent || !m_pWaveFile )
+		return;
+
+	drawHelper.DrawColoredText( "Arial", 9, FW_NORMAL, PEColor( COLOR_PHONEME_TIMING_TAG ), rc, "Timing Tags:" );
+
+	float starttime = m_nLeftOffset / GetPixelsPerSecond();
+	float endtime = w2() / GetPixelsPerSecond() + starttime;
+
+	for ( int i = 0; i < m_pEvent->GetNumRelativeTags(); i++ )
+	{
+		CEventRelativeTag *tag = m_pEvent->GetRelativeTag( i );
+		if ( !tag )
+			continue;
+
+		// 
+		float tagtime = tag->GetPercentage() * m_pWaveFile->GetRunningLength();
+		if ( tagtime < starttime || tagtime > endtime )
+			continue;
+
+		float frac = ( tagtime - starttime ) / ( endtime - starttime );
+
+		int left = rc.left + (int)( frac * ( float )( rc.right - rc.left ) + 0.5f );
+
+		RECT rcMark;
+		rcMark = rc;
+		rcMark.top = rc.bottom - 8;
+		rcMark.bottom = rc.bottom;
+		rcMark.left = left - 4;
+		rcMark.right = left + 4;
+
+		drawHelper.DrawTriangleMarker( rcMark, PEColor( COLOR_PHONEME_TIMING_TAG ) );
+
+		RECT rcText;
+		rcText = rc;
+		rcText.bottom = rc.bottom - 10;
+		rcText.top = rcText.bottom - 10;
+	
+		int len = drawHelper.CalcTextWidth( "Arial", 9, FW_NORMAL, tag->GetName() );
+		rcText.left = left - len / 2;
+		rcText.right = rcText.left + len + 2;
+
+		drawHelper.DrawColoredText( "Arial", 9, FW_NORMAL, PEColor( COLOR_PHONEME_TIMING_TAG ), rcText, tag->GetName() );
+	}
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+void PhonemeEditor::redraw( void )
+{
+	if ( !ToolCanDraw() )
+		return;
+
+	CChoreoWidgetDrawHelper drawHelper( this );
+	HandleToolRedraw( drawHelper );
+
+	if ( !m_pWaveFile )
+		return;
+
+	HDC dc = drawHelper.GrabDC();
+
+	RECT rc;
+	GetWorkspaceRect( rc );
+
+	float starttime = m_nLeftOffset / GetPixelsPerSecond();
+	float endtime = w2() / GetPixelsPerSecond() + starttime;
+
+	// Now draw the time legend
+	RECT rcLabel;
+	float granularity = 0.5f; 
+
+	drawHelper.DrawColoredLine( PEColor( COLOR_PHONEME_TIMELINE ), PS_SOLID, 1, rc.left, rc.bottom - m_nTickHeight, rc.right, rc.bottom - m_nTickHeight );
+
+	if ( GetMode() != MODE_EMPHASIS )
+	{
+		Emphasis_Redraw( drawHelper, rc );
+	}
+
+	sound->RenderWavToDC( 
+		dc, 
+		rc, 
+		PEColor( COLOR_PHONEME_WAVDATA ), 
+		starttime, 
+		endtime, 
+		m_pWaveFile,
+		m_bSelectionActive,
+		m_nSelection[ 0 ],
+		m_nSelection[ 1 ] );
+
+	float f = SnapTime( starttime, granularity );
+	while ( f <= endtime )
+	{
+		float frac = ( f - starttime ) / ( endtime - starttime );
+		if ( frac >= 0.0f && frac <= 1.0f )
+		{
+			drawHelper.DrawColoredLine( ( COLOR_PHONEME_TIMELINE_MAJORTICK ), PS_SOLID, 1, (int)( frac * rc.right ), rc.top, (int)( frac * rc.right ), rc.bottom - m_nTickHeight );
+
+			rcLabel.left = (int)( frac * rc.right );
+			rcLabel.bottom = rc.bottom;
+			rcLabel.top = rcLabel.bottom - 10;
+
+			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, PEColor( COLOR_PHONEME_TEXT ), rcLabel, sz );
+		}
+		f += granularity;
+	}
+
+	HBRUSH br = CreateSolidBrush( PEColor( COLOR_PHONEME_TEXT ) );
+
+	FrameRect( dc, &rc, br );
+
+	DeleteObject( br );
+
+	RECT rcTags = rc;
+	rcTags.top = TAG_TOP;
+	rcTags.bottom = TAG_BOTTOM;
+
+	DrawRelativeTags( drawHelper, rcTags );
+
+	int fontsize = 9;
+	RECT rcText = rc;
+	rcText.top = rcText.bottom + 5;
+	rcText.left += 5;
+	rcText.bottom = rcText.top + fontsize + 1;
+	rcText.right -= 5;
+
+	int fontweight = FW_NORMAL;
+
+	const char *font = "Arial";
+
+	if ( m_nLastExtractionResult != SR_RESULT_NORESULT )
+	{
+		COLORREF clr = PEColor( COLOR_PHONEME_EXTRACTION_RESULT_OTHER );
+		switch ( m_nLastExtractionResult )
+		{
+		case SR_RESULT_ERROR:
+			clr = PEColor( COLOR_PHONEME_EXTRACTION_RESULT_ERROR );
+			break;
+		case SR_RESULT_SUCCESS:
+			clr = PEColor( COLOR_PHONEME_EXTRACTION_RESULT_SUCCESS );
+			break;
+		case SR_RESULT_FAILED:
+			clr = PEColor( COLOR_PHONEME_EXTRACTION_RESULT_FAIL );
+			break;
+		default:
+			break;
+		}
+
+		drawHelper.DrawColoredText( font, fontsize, fontweight, clr, rcText,
+			"Last Extraction Result:  %s", GetExtractionResultString( m_nLastExtractionResult ) );
+	
+		OffsetRect( &rcText, 0, fontsize + 1 );
+	}
+
+	if ( m_pEvent && !Q_stristr( m_pEvent->GetParameters(), ".wav" ) )
+	{
+		drawHelper.DrawColoredText( font, fontsize, fontweight, PEColor( COLOR_PHONEME_TEXT ), rcText,
+			"Sound: '%s', file: %s, length %.2f seconds", 
+			m_pEvent->GetParameters(),
+			m_WorkFile.m_szWaveFile, 
+			m_pWaveFile->GetRunningLength() );
+	}
+	else
+	{
+		drawHelper.DrawColoredText( font, fontsize, fontweight, PEColor( COLOR_PHONEME_TEXT ), rcText,
+			"File: %s, length %.2f seconds", m_WorkFile.m_szWaveFile, m_pWaveFile->GetRunningLength() );
+	}
+
+	OffsetRect( &rcText, 0, fontsize + 1 );
+
+	drawHelper.DrawColoredText( font, fontsize, fontweight, PEColor( COLOR_PHONEME_TEXT ), rcText,
+		"Number of samples %i at %ikhz (%i bits/sample) %s", (int) (m_pWaveFile->GetRunningLength() * m_pWaveFile->SampleRate() ), m_pWaveFile->SampleRate(), (m_pWaveFile->SampleSize()<<3), m_Tags.GetVoiceDuck() ? "duck other audio" : "no ducking" );
+
+	OffsetRect( &rcText, 0, fontsize + 1 );
+
+	drawHelper.DrawColoredText( font, fontsize, fontweight, PEColor( COLOR_PHONEME_TEXT ), rcText,
+		"[ %i ] Words [ %i ] Phonemes / Zoom %i %%", m_Tags.m_Words.Size(), m_Tags.CountPhonemes(), m_nTimeZoom );
+
+	if ( m_pEvent )
+	{
+		OffsetRect( &rcText, 0, fontsize + 1 );
+
+		drawHelper.DrawColoredText( font, fontsize, fontweight, PEColor( COLOR_PHONEME_TEXT ), rcText,
+			"Event %s", m_pEvent->GetName() );
+	}
+
+	OffsetRect( &rcText, 0, fontsize + 1 );
+
+	drawHelper.DrawColoredText( font, fontsize, fontweight, PEColor( COLOR_PHONEME_TEXT ), rcText,
+		"Using:  %s", GetSpeechAPIName() );
+
+
+	char text[ 4096 ];
+	sprintf( text, "Sentence Text:  %s", m_Tags.GetText() );
+
+	int halfwidth = ( rc.right - rc.left ) / 2;
+
+	rcText = rc;
+	rcText.left = halfwidth;
+	rcText.top = rcText.bottom + 5;
+	rcText.right = rcText.left + halfwidth * 0.6;
+
+	drawHelper.CalcTextRect( font, fontsize, fontweight, halfwidth, rcText, text );
+
+	drawHelper.DrawColoredTextMultiline( font, fontsize, fontweight, PEColor( COLOR_PHONEME_TEXT ), rcText,
+		text );
+
+	CWordTag *cw = GetSelectedWord();
+	if ( cw )
+	{
+		char wordInfo[ 512 ];
+		sprintf( wordInfo, "Word:  %s, start %.2f end %.2f, duration %.2f ms phonemes %i",
+			cw->GetWord(), cw->m_flStartTime, cw->m_flEndTime, 1000.0f * ( cw->m_flEndTime - cw->m_flStartTime ),
+			cw->m_Phonemes.Size() );
+
+		int length = drawHelper.CalcTextWidth( font, fontsize, fontweight, wordInfo );
+
+		OffsetRect( &rcText, 0, ( rcText.bottom - rcText.top ) + 2 );
+
+		rcText.left = rcText.right - length - 10;
+		rcText.bottom = rcText.top + fontsize + 1;
+
+		drawHelper.DrawColoredText( font, fontsize, fontweight, PEColor( COLOR_PHONEME_TEXT ), rcText, wordInfo );
+	}
+
+	CPhonemeTag *cp = GetSelectedPhoneme();
+	if ( cp )
+	{
+		char phonemeInfo[ 512 ];
+		sprintf( phonemeInfo, "Phoneme:  %s, start %.2f end %.2f, duration %.2f ms",
+			ConvertPhoneme( cp->GetPhonemeCode() ), cp->GetStartTime(), cp->GetEndTime(), 1000.0f * ( cp->GetEndTime() - cp->GetStartTime() ) );
+
+		int length = drawHelper.CalcTextWidth( font, fontsize, fontweight, phonemeInfo );
+
+		OffsetRect( &rcText, 0, ( rcText.bottom - rcText.top ) + 2 );
+
+		rcText.left = rcText.right - length - 10;
+		rcText.bottom = rcText.top + fontsize + 1;
+
+		drawHelper.DrawColoredText( font, fontsize, fontweight, PEColor( COLOR_PHONEME_TEXT ), rcText, phonemeInfo );
+	}
+
+	// Draw playback rate
+	{
+		char sz[ 48 ];
+		sprintf( sz, "Speed: %.2fx", m_flPlaybackRate );
+
+		int length = drawHelper.CalcTextWidth( font, fontsize, fontweight, sz);
+		
+		rcText = rc;
+		rcText.top = rc.bottom + 60;
+		rcText.bottom = rcText.top + fontsize + 1;
+		rcText.left = m_pPlaybackRate->x() + m_pPlaybackRate->w() - x();
+		rcText.right = rcText.left + length + 2;
+
+		drawHelper.DrawColoredText( font, fontsize, fontweight, 
+			PEColor( COLOR_PHONEME_TEXT ), rcText, sz );
+	}
+
+	if ( m_UndoStack.Size() > 0 )
+	{
+		int length = drawHelper.CalcTextWidth( font, fontsize, fontweight, 
+			"Undo levels:  %i/%i", m_nUndoLevel, m_UndoStack.Size() );
+
+		rcText = rc;
+		rcText.top = rc.bottom + 60;
+		rcText.bottom = rcText.top + fontsize + 1;
+		rcText.right -= 5;
+		rcText.left = rcText.right - length - 10;
+
+		drawHelper.DrawColoredText( font, fontsize, fontweight, PEColor( COLOR_PHONEME_EXTRACTION_RESULT_SUCCESS ), rcText,
+			"Undo levels:  %i/%i", m_nUndoLevel, m_UndoStack.Size() );
+	}
+
+	float endfrac = ( m_pWaveFile->GetRunningLength() - starttime ) / ( endtime - starttime );
+	if ( endfrac >= 0.0f && endfrac <= 1.0f )
+	{
+		int endpos = ( int ) ( rc.right * endfrac );
+
+		drawHelper.DrawColoredLine( PEColor( COLOR_PHONEME_WAV_ENDPOINT ), PS_DOT, 2, endpos, rc.top, endpos, rc.bottom - m_nTickHeight );
+	}
+
+	DrawPhonemes( drawHelper, rc, m_Tags, 0 );
+
+	DrawPhonemes( drawHelper, rc, m_TagsExt, 1, false );
+
+	DrawWords( drawHelper, rc, m_Tags, 0 );
+
+	DrawWords( drawHelper, rc, m_TagsExt, 1, false );
+
+	if ( GetMode() == MODE_EMPHASIS )
+	{
+		Emphasis_Redraw( drawHelper, rc );
+	}
+
+	DrawScrubHandle( drawHelper );
+}
+
+#define MOTION_RANGE 3000
+#define MOTION_MAXSTEP 500
+//-----------------------------------------------------------------------------
+// Purpose: Brown noise simulates brownian motion centered around 127.5 but we cap the walking
+//  to just a couple of units
+// Input  : *buffer - 
+//			count - 
+// Output : static void
+//-----------------------------------------------------------------------------
+static void WriteBrownNoise( void *buffer, int count )
+{
+	int currentValue = 127500;
+	int maxValue = currentValue + ( MOTION_RANGE / 2 );
+	int minValue = currentValue - ( MOTION_RANGE / 2 );
+
+	unsigned char *pos = ( unsigned char *)buffer;
+
+	while ( --count >= 0 )
+	{
+		currentValue += random->RandomInt( -MOTION_MAXSTEP, MOTION_MAXSTEP );
+		currentValue = min( maxValue, currentValue );
+		currentValue = max( minValue, currentValue );
+
+		// Downsample to 0-255 range
+		*pos++ = (unsigned char)( ( (float)currentValue / 1000.0f ) + 0.5f );
+	}
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: Replace with brownian noice parts of the wav file that we dont' want processed by the
+//  speech recognizer
+// Input  : store - 
+//			*format - 
+//			chunkname - 
+//			*buffer - 
+//			buffersize - 
+//-----------------------------------------------------------------------------
+void PhonemeEditor::ResampleChunk( IterateOutputRIFF& store, void *format, int chunkname, char *buffer, int buffersize, int start_silence /*=0*/, int end_silence /*=0*/ )
+{
+	WAVEFORMATEX *pFormat = ( WAVEFORMATEX * )format;
+	Assert( pFormat );
+
+	if ( pFormat->wFormatTag == WAVE_FORMAT_PCM )
+	{
+		int silience_time = start_silence + end_silence;
+
+		// Leave room for silence at start + end
+		int resamplesize = buffersize + silience_time * pFormat->nSamplesPerSec;
+		char *resamplebuffer = new char[ resamplesize + 4 ];
+		memset( resamplebuffer, (unsigned char)128, resamplesize + 4 );
+
+		int startpos = (int)( start_silence * pFormat->nSamplesPerSec );
+
+		if ( startpos > 0 )
+		{
+			WriteBrownNoise( resamplebuffer, startpos );
+		}
+
+		if ( startpos + buffersize < resamplesize )
+		{
+			WriteBrownNoise( &resamplebuffer[ startpos + buffersize ], resamplesize - ( startpos + buffersize ) );
+		}
+
+		memcpy( &resamplebuffer[ startpos ], buffer, buffersize );
+
+		store.ChunkWriteData( resamplebuffer, resamplesize );
+		return;
+	}
+
+	store.ChunkWriteData( buffer, buffersize );
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+void PhonemeEditor::ReadLinguisticTags( void )
+{
+	if ( !m_pWaveFile )
+		return;
+
+	CAudioSource *wave = sound->LoadSound( m_WorkFile.m_szWorkingFile );
+	if ( !wave )
+		return;
+
+	m_Tags.Reset();
+
+	CSentence *sentence = wave->GetSentence();
+	if ( sentence )
+	{
+		// Copy data from sentence to m_Tags
+		m_Tags.Reset();
+		m_Tags = *sentence;
+	}
+
+	delete wave;
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: Switch wave files
+// Input  : *wavefile - 
+//			force - 
+//-----------------------------------------------------------------------------
+void PhonemeEditor::SetCurrentWaveFile( const char *wavefile, bool force /*=false*/, CChoreoEvent *event /*=NULL*/ )
+{
+	// No change?
+	if ( !force && !stricmp( m_WorkFile.m_szWaveFile, wavefile ) )
+		return;
+
+	StopPlayback();
+
+	if ( GetDirty() )
+	{
+		int retval = mxMessageBox( this, va( "Save current changes to %s", m_WorkFile.m_szWaveFile ),
+			"Phoneme Editor", MX_MB_QUESTION | MX_MB_YESNOCANCEL );
+
+		// Cancel
+		if ( retval == 2 )
+			return;
+
+		// Yes
+		if ( retval == 0 )
+		{
+			CommitChanges();
+		}
+	}
+
+	ClearExtracted();
+
+	m_Tags.Reset();
+	m_TagsExt.Reset();
+
+	Deselect();
+
+	if ( m_pWaveFile )
+	{
+		char fn[ 512 ];
+		Q_snprintf( fn, sizeof( fn ), "%s%s", m_WorkFile.m_szBasePath, m_WorkFile.m_szWorkingFile );
+		filesystem->RemoveFile( fn, "GAME" );
+	}
+
+	delete m_pWaveFile;
+	m_pWaveFile = NULL;
+
+	SetDirty( false );
+
+	// Set up event and scene
+	m_pEvent = event;
+
+	// Try an dload new sound
+	m_pWaveFile = sound->LoadSound( wavefile );
+	Q_strncpy( m_WorkFile.m_szWaveFile, wavefile, sizeof( m_WorkFile.m_szWaveFile ) );
+
+	char fullpath[ 512 ];
+	filesystem->RelativePathToFullPath( wavefile, "GAME", fullpath, sizeof( fullpath ) );
+	int len = Q_strlen( fullpath );
+	int charstocopy = len - Q_strlen( wavefile ) + 1;
+	m_WorkFile.m_szBasePath[ 0 ] = 0;
+	if ( charstocopy >= 0 )
+	{
+		Q_strncpy( m_WorkFile.m_szBasePath, fullpath, charstocopy );
+		m_WorkFile.m_szBasePath[ charstocopy ] = 0;
+	}
+	Q_StripExtension( wavefile, m_WorkFile.m_szWorkingFile, sizeof( m_WorkFile.m_szWorkingFile ) );
+	Q_strncat( m_WorkFile.m_szWorkingFile, "_work.wav", sizeof( m_WorkFile.m_szWorkingFile ), COPY_ALL_CHARACTERS );
+
+	Q_FixSlashes( m_WorkFile.m_szWaveFile );
+	Q_FixSlashes( m_WorkFile.m_szWorkingFile );
+	Q_FixSlashes( m_WorkFile.m_szBasePath );
+
+	if ( !m_pWaveFile )
+	{
+		Con_ErrorPrintf( "Couldn't set current .wav file to %s\n", m_WorkFile.m_szWaveFile );
+		return;
+	}
+
+	Con_Printf( "Current .wav file set to %s\n", m_WorkFile.m_szWaveFile );
+
+	g_pWaveBrowser->SetCurrent( m_WorkFile.m_szWaveFile );
+
+	// Copy over and overwrite file
+	FPCopyFile( m_WorkFile.m_szWaveFile, m_WorkFile.m_szWorkingFile, false );
+	// Make it writable
+	MakeFileWriteable( m_WorkFile.m_szWorkingFile );
+
+	ReadLinguisticTags();
+
+	Deselect();
+
+	RepositionHSlider();
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+// Input  : x - 
+//-----------------------------------------------------------------------------
+void PhonemeEditor::MoveTimeSliderToPos( int x )
+{
+	m_nLeftOffset = x;
+	m_pHorzScrollBar->setValue( m_nLeftOffset );
+	InvalidateRect( (HWND)m_pHorzScrollBar->getHandle(), NULL, TRUE );
+	redraw();
+}
+
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+// Output : int
+//-----------------------------------------------------------------------------
+int PhonemeEditor::ComputeHPixelsNeeded( void )
+{
+	int pixels = 0;
+
+	if ( m_pWaveFile )
+	{
+		float maxtime = m_pWaveFile->GetRunningLength();
+		maxtime += 1.0f;
+		pixels = (int)( maxtime * GetPixelsPerSecond() );
+	}
+
+	return pixels;
+
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+void PhonemeEditor::RepositionHSlider( void )
+{
+	int pixelsneeded = ComputeHPixelsNeeded();
+
+	if ( pixelsneeded <= w2() )
+	{
+		m_pHorzScrollBar->setVisible( false );
+	}
+	else
+	{
+		m_pHorzScrollBar->setVisible( true );
+	}
+
+	m_pHorzScrollBar->setBounds( 0, GetCaptionHeight(), w2(), 12 );
+
+	m_pHorzScrollBar->setRange( 0, pixelsneeded );
+	m_pHorzScrollBar->setValue( 0 );
+	m_nLeftOffset = 0;
+
+	m_pHorzScrollBar->setPagesize( w2() );
+
+	redraw();
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+// Output : float
+//-----------------------------------------------------------------------------
+float PhonemeEditor::GetPixelsPerSecond( void )
+{
+	return m_flPixelsPerSecond * GetTimeZoomScale();
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+// Output : float
+//-----------------------------------------------------------------------------
+float PhonemeEditor::GetTimeZoomScale( void )
+{
+	return ( float )m_nTimeZoom / 100.0f;
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+// Input  : scale - 
+//-----------------------------------------------------------------------------
+void PhonemeEditor::SetTimeZoomScale( int scale )
+{
+	m_nTimeZoom = scale;
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+// Input  : dt - 
+//-----------------------------------------------------------------------------
+void PhonemeEditor::Think( float dt )
+{
+	if ( !m_pWaveFile )
+		return;
+
+	bool scrubbing = ( m_nDragType == DRAGTYPE_SCRUBBER ) ? true : false;
+	ScrubThink( dt, scrubbing );
+
+	if ( m_pMixer && !sound->IsSoundPlaying( m_pMixer ) )
+	{
+		m_pMixer = NULL;
+	}
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+// Input  : mx - 
+//			my - 
+// Output : Returns true on success, false on failure.
+//-----------------------------------------------------------------------------
+int PhonemeEditor::IsMouseOverBoundary( mxEvent *event )
+{
+	int mx, my;
+
+	mx = (short)event->x;
+	my = (short)event->y;
+
+	// Deterime if phoneme boundary is under the cursor
+	//
+	if ( !m_pWaveFile )
+		return BOUNDARY_NONE;
+
+	if ( !(event->modifiers & mxEvent::KeyCtrl ) ) 
+	{
+		return BOUNDARY_NONE;
+	}
+
+	RECT rc;
+	GetWorkspaceRect( rc );
+
+	if ( IsMouseOverPhonemeRow( my ) )
+	{
+		float starttime = m_nLeftOffset / GetPixelsPerSecond();
+		float endtime = w2() / GetPixelsPerSecond() + starttime;
+
+		int		mouse_tolerance = 3;
+
+		for ( int i = 0; i < m_Tags.m_Words.Size(); i++ )
+		{
+			CWordTag *word = m_Tags.m_Words[ i ];
+
+			for ( int k = 0; k < word->m_Phonemes.Size(); k++ )
+			{
+				CPhonemeTag *pPhoneme = word->m_Phonemes[ k ];
+
+				float t1 = pPhoneme->GetStartTime();
+				float t2 = pPhoneme->GetEndTime();
+
+				// Tag it
+				float frac1 = ( t1 - starttime ) / ( endtime - starttime );
+				float frac2 = ( t2 - starttime ) / ( endtime - starttime );
+
+				int xpos1 = ( int )( frac1 * w2() );
+				int xpos2 = ( int )( frac2 * w2() );
+				if ( abs( xpos1 - mx ) <= mouse_tolerance ||
+					 abs( xpos2 - mx ) <= mouse_tolerance )
+				{
+					return BOUNDARY_PHONEME;
+				}
+			}
+		}
+	}
+
+	if ( IsMouseOverWordRow( my ) )
+	{
+		float starttime = m_nLeftOffset / GetPixelsPerSecond();
+		float endtime = w2() / GetPixelsPerSecond() + starttime;
+
+		int		mouse_tolerance = 3;
+
+		for ( int k = 0; k < m_Tags.m_Words.Size(); k++ )
+		{
+			CWordTag *word = m_Tags.m_Words[ k ];
+
+			float t1 = word->m_flStartTime;
+			float t2 = word->m_flEndTime;
+
+			// Tag it
+			float frac1 = ( t1 - starttime ) / ( endtime - starttime );
+			float frac2 = ( t2 - starttime ) / ( endtime - starttime );
+
+			int xpos1 = ( int )( frac1 * w2() );
+			int xpos2 = ( int )( frac2 * w2() );
+			if ( ( abs( xpos1 - mx ) <= mouse_tolerance ) ||
+				 ( abs( xpos2 - mx ) <= mouse_tolerance ) )
+			{
+				return BOUNDARY_WORD;
+			}
+		}
+	}
+
+	return BOUNDARY_NONE;
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+void PhonemeEditor::DrawFocusRect( char *reason )
+{
+	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 );
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+// Input  : &rc - 
+//-----------------------------------------------------------------------------
+void PhonemeEditor::GetWorkspaceRect( RECT &rc )
+{
+	GetClientRect( (HWND)getHandle(), &rc );
+	
+	rc.top += TAG_BOTTOM;
+	rc.bottom = rc.bottom - 75 - MODE_TAB_OFFSET;
+
+	InflateRect( &rc, -1, -1 );
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+// Input  : mx - 
+//			my - 
+//-----------------------------------------------------------------------------
+void PhonemeEditor::ShowWordMenu( CWordTag *word, int mx, int my )
+{
+	CountSelected();
+
+	mxPopupMenu *pop = new mxPopupMenu();
+	Assert( pop );
+
+	pop->add( va( "Edit sentence text..." ), IDC_EDITWORDLIST );
+	
+	if ( m_nSelectedWordCount > 0 && word )
+	{
+		pop->addSeparator();
+
+		pop->add( va( "Delete %s", m_nSelectedWordCount > 1 ? "words" : va( "'%s'", word->GetWord() ) ), IDC_EDIT_DELETEWORD );
+
+		if ( m_nSelectedWordCount == 1 )
+		{
+			int index = IndexOfWord( word );
+			bool valid = false;
+			if ( index != -1 )
+			{
+				SetClickedPhoneme( index, -1 );
+				valid = true;
+			}
+
+			if ( valid )
+			{
+				pop->add( va( "Edit word '%s'...", word->GetWord() ), IDC_EDIT_WORD );
+
+				float nextGap = GetTimeGapToNextWord( true, word );
+				float prevGap = GetTimeGapToNextWord( false, word );
+
+				if ( nextGap > MINIMUM_WORD_GAP ||
+					 prevGap > MINIMUM_WORD_GAP )
+				{
+					pop->addSeparator();
+					if ( prevGap > MINIMUM_WORD_GAP )
+					{
+						pop->add( va( "Insert word before '%s'...", word->GetWord() ), IDC_EDIT_INSERTWORDBEFORE );
+					}
+					if ( nextGap > MINIMUM_WORD_GAP )
+					{
+						pop->add( va( "Insert word after '%s'...", word->GetWord() ), IDC_EDIT_INSERTWORDAFTER );
+					}
+				}
+
+				if ( word->m_Phonemes.Size() == 0 )
+				{
+					pop->addSeparator();
+					pop->add( va( "Add phoneme to '%s'...", word->GetWord() ), IDC_EDIT_INSERTFIRSTPHONEMEOFWORD );
+				}
+
+				pop->addSeparator();
+				pop->add( va( "Select all words after '%s'", word->GetWord() ), IDC_SELECT_WORDSRIGHT );
+				pop->add( va( "Select all words before '%s'", word->GetWord() ), IDC_SELECT_WORDSLEFT );
+			}
+		}
+	}
+
+	if ( AreSelectedWordsContiguous() && m_nSelectedWordCount > 1 )
+	{
+		pop->addSeparator();
+		pop->add( va( "Merge words" ), IDC_SNAPWORDS );
+		
+		if ( m_nSelectedWordCount == 2 )
+		{
+			pop->add( va( "Separate words" ), IDC_SEPARATEWORDS );
+		}
+	}
+
+	if ( m_nSelectedWordCount > 0 )
+	{
+		pop->addSeparator();
+
+		pop->add( va( "Deselect all" ), IDC_DESELECT_PHONEMESANDWORDS );
+	}
+
+	if ( m_Tags.m_Words.Size() > 0 )
+	{
+		pop->addSeparator();
+		pop->add( va( "Cleanup words/phonemes" ), IDC_CLEANUP );
+	}
+
+	if ( m_Tags.m_Words.Size() > 0 )
+	{
+		pop->addSeparator();
+		pop->add( va( "Realign phonemes to words" ), IDC_REALIGNPHONEMES );
+	}
+
+
+	pop->popup( this, mx, my );
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+// Input  : mx - 
+//			my - 
+//-----------------------------------------------------------------------------
+void PhonemeEditor::ShowPhonemeMenu( CPhonemeTag *pho, int mx, int my )
+{
+	CountSelected();
+
+	SetClickedPhoneme( -1, -1 );
+
+	if ( !pho )
+		return;
+
+	if ( m_Tags.CountPhonemes() == 0 )
+	{
+		Con_Printf( "No phonemes, try extracting from .wav first\n" );
+		return;
+	}
+
+	mxPopupMenu *pop = new mxPopupMenu();
+	bool valid = false;
+	CWordTag *tag = m_Tags.GetWordForPhoneme( pho );
+	if ( tag )
+	{
+		int wordNum = IndexOfWord( tag );
+		int pi = tag->IndexOfPhoneme( pho );
+
+		SetClickedPhoneme( wordNum, pi );
+		valid = true;
+	}
+
+	if ( valid )
+	{
+		if ( m_nSelectedPhonemeCount == 1 )
+		{
+			pop->add( va( "Edit '%s'...", ConvertPhoneme( pho->GetPhonemeCode() ) ), IDC_EDIT_PHONEME );
+
+			float nextGap = GetTimeGapToNextPhoneme( true, pho );
+			float prevGap = GetTimeGapToNextPhoneme( false, pho );
+
+			if ( nextGap > MINIMUM_PHONEME_GAP ||
+				 prevGap > MINIMUM_PHONEME_GAP )
+			{
+				pop->addSeparator();
+				if ( prevGap > MINIMUM_PHONEME_GAP )
+				{
+					pop->add( va( "Insert phoneme before '%s'...", ConvertPhoneme( pho->GetPhonemeCode() ) ), IDC_EDIT_INSERTPHONEMEBEFORE );
+				}
+				if ( nextGap > MINIMUM_PHONEME_GAP )
+				{
+					pop->add( va( "Insert phoneme after '%s'...", ConvertPhoneme( pho->GetPhonemeCode() ) ), IDC_EDIT_INSERTPHONEMEAFTER );
+				}
+			}
+
+			pop->addSeparator();
+			pop->add( va( "Select all phonemes after '%s'", ConvertPhoneme( pho->GetPhonemeCode() ) ), IDC_SELECT_PHONEMESRIGHT );
+			pop->add( va( "Select all phonemes before '%s'",ConvertPhoneme( pho->GetPhonemeCode() ) ), IDC_SELECT_PHONEMESLEFT );
+
+			pop->addSeparator();
+		}
+				
+		if ( AreSelectedPhonemesContiguous() && m_nSelectedPhonemeCount > 1 )
+		{
+			pop->add( va( "Merge phonemes" ), IDC_SNAPPHONEMES );
+			if ( m_nSelectedPhonemeCount == 2 )
+			{
+				pop->add( va( "Separate phonemes" ), IDC_SEPARATEPHONEMES );
+			}
+
+			pop->addSeparator();
+		}
+		
+		if ( m_nSelectedPhonemeCount >= 1 )
+		{
+			pop->add( va( "Delete %s", 
+				m_nSelectedPhonemeCount == 1 ? va( "'%s'", ConvertPhoneme( pho->GetPhonemeCode() ) ) : "phonemes" ), IDC_EDIT_DELETEPHONEME );
+
+			pop->addSeparator();
+			pop->add( va( "Deselect all" ), IDC_DESELECT_PHONEMESANDWORDS );
+		}
+	}
+
+
+	if ( m_Tags.m_Words.Size() > 0 )
+	{
+		pop->addSeparator();
+		pop->add( va( "Cleanup words/phonemes" ), IDC_CLEANUP );
+	}
+
+	if ( m_Tags.m_Words.Size() > 0 )
+	{
+		pop->addSeparator();
+		pop->add( va( "Realign words to phonemes" ), IDC_REALIGNWORDS );
+	}
+
+	pop->popup( this, mx, my );
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+// Input  : mx - 
+// Output : float
+//-----------------------------------------------------------------------------
+float PhonemeEditor::GetTimeForPixel( int mx )
+{
+	RECT rc;
+	GetWorkspaceRect( rc );
+
+	float starttime = m_nLeftOffset / GetPixelsPerSecond();
+	float time = (float)mx / GetPixelsPerSecond() + starttime;
+
+	return time;
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+// Input  : time - 
+//			**pp1 - 
+//			**pp2 - 
+// Output : Returns true on success, false on failure.
+//-----------------------------------------------------------------------------
+bool PhonemeEditor::FindSpanningPhonemes( float time, CPhonemeTag **pp1, CPhonemeTag **pp2 )
+{
+	Assert( pp1 && pp2 );
+
+	*pp1 = NULL;
+	*pp2 = NULL;
+
+	// Three pixels
+	double time_epsilon = ( 1.0f / GetPixelsPerSecond() ) * 3;
+
+	CPhonemeTag *previous = NULL;
+
+	for ( int w = 0; w < m_Tags.m_Words.Size(); w++ )
+	{
+		CWordTag *word = m_Tags.m_Words[ w ];
+
+		for ( int i = 0; i < word->m_Phonemes.Size(); i++ )
+		{
+			CPhonemeTag *current = word->m_Phonemes[ i ];
+			double dt;
+
+			if ( !previous )
+			{
+				dt = fabs( current->GetStartTime() - time );
+				if ( dt < time_epsilon )
+				{
+					*pp2 = current;
+					return true;
+				}
+			}
+			else
+			{
+				int found = 0;
+
+				dt = fabs( previous->GetEndTime() - time );
+				if ( dt < time_epsilon )
+				{
+					*pp1 = previous;
+					found++;
+				}
+
+				dt = fabs( current->GetStartTime() - time );
+				if ( dt < time_epsilon )
+				{
+					*pp2 = current;
+					found++;
+				}
+
+				if ( found != 0 )
+				{
+					return true;
+				}
+			}
+		
+			previous = current;
+		}
+	}
+
+	if ( m_Tags.m_Words.Size() > 0 )
+	{
+		// Check last word, but only if it has some phonemes
+		CWordTag *lastWord = m_Tags.m_Words[ m_Tags.m_Words.Size() - 1 ];
+		if ( lastWord && 
+			( lastWord->m_Phonemes.Size() > 0 ) )
+		{
+
+			CPhonemeTag *last = lastWord->m_Phonemes[ lastWord->m_Phonemes.Size() - 1 ];
+			float dt;
+			dt = fabs( last->GetEndTime() - time );
+			if ( dt < time_epsilon )
+			{
+				*pp1 = last;
+				return true;
+			}
+		}
+	}
+
+	return false;
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+// Input  : time - 
+//			**pp1 - 
+//			**pp2 - 
+// Output : Returns true on success, false on failure.
+//-----------------------------------------------------------------------------
+bool PhonemeEditor::FindSpanningWords( float time, CWordTag **pp1, CWordTag **pp2 )
+{
+	Assert( pp1 && pp2 );
+
+	*pp1 = NULL;
+	*pp2 = NULL;
+
+	// Three pixels
+	double time_epsilon = ( 1.0f / GetPixelsPerSecond() ) * 3;
+
+	CWordTag *previous = NULL;
+	for ( int i = 0; i < m_Tags.m_Words.Size(); i++ )
+	{
+		CWordTag *current = m_Tags.m_Words[ i ];
+		double dt;
+
+		if ( !previous )
+		{
+			dt = fabs( current->m_flStartTime - time );
+			if ( dt < time_epsilon )
+			{
+				*pp2 = current;
+				return true;
+			}
+		}
+		else
+		{
+			int found = 0;
+
+			dt = fabs( previous->m_flEndTime - time );
+			if ( dt < time_epsilon )
+			{
+				*pp1 = previous;
+				found++;
+			}
+
+			dt = fabs( current->m_flStartTime - time );
+			if ( dt < time_epsilon )
+			{
+				*pp2 = current;
+				found++;
+			}
+
+			if ( found != 0 )
+			{
+				return true;
+			}
+		}
+	
+		previous = current;
+	}
+
+	if ( m_Tags.m_Words.Size() > 0 )
+	{
+		CWordTag *last = m_Tags.m_Words[ m_Tags.m_Words.Size() - 1 ];
+		float dt;
+		dt = fabs( last->m_flEndTime - time );
+		if ( dt < time_epsilon )
+		{
+			*pp1 = last;
+			return true;
+		}
+	}
+
+	return false;
+}
+
+int	PhonemeEditor::FindWordForTime( float time )
+{
+	for ( int i = 0; i < m_Tags.m_Words.Size(); i++ )
+	{
+		CWordTag *pCurrent = m_Tags.m_Words[ i ];
+
+		if ( time < pCurrent->m_flStartTime )
+			continue;
+
+		if ( time > pCurrent->m_flEndTime )
+			continue;
+
+		return i;
+	}
+
+	return -1;
+}
+
+void PhonemeEditor::FinishWordDrag( int startx, int endx )
+{
+	float clicktime	= GetTimeForPixel( startx );
+	float endtime	= GetTimeForPixel( endx );
+
+	float dt = endtime - clicktime;
+
+	SetDirty( true );
+
+	PushUndo();
+
+	TraverseWords( &PhonemeEditor::ITER_MoveSelectedWords, dt );
+
+	RealignPhonemesToWords( false );
+	CleanupWordsAndPhonemes( false );
+
+	PushRedo();
+
+	redraw();
+}
+
+void PhonemeEditor::FinishWordMove( int startx, int endx )
+{
+	float clicktime	= GetTimeForPixel( startx );
+	float endtime	= GetTimeForPixel( endx );
+
+	// Find the phonemes who have the closest start/endtime to the starting click time
+	CWordTag *current, *next;
+
+	if ( !FindSpanningWords( clicktime, &current, &next ) )
+	{
+		return;
+	}
+
+	SetDirty( true );
+
+	PushUndo();
+
+	if ( current && !next )
+	{
+		// cap movement
+		current->m_flEndTime += ( endtime - clicktime );
+	}
+	else if ( !current && next )
+	{
+		// cap movement
+		next->m_flStartTime += ( endtime - clicktime );
+	}
+	else
+	{
+		// cap movement
+		endtime = min( endtime, next->m_flEndTime - 1.0f / GetPixelsPerSecond() );
+		endtime = max( endtime, current->m_flStartTime + 1.0f / GetPixelsPerSecond() );
+
+		current->m_flEndTime = endtime;
+		next->m_flStartTime = endtime;
+	}
+
+	RealignPhonemesToWords( false );
+	CleanupWordsAndPhonemes( false );
+
+	PushRedo();
+
+	redraw();
+}
+
+CPhonemeTag *PhonemeEditor::FindPhonemeForTime( float time )
+{
+	for ( int w = 0 ; w < m_Tags.m_Words.Size(); w++ )
+	{
+		CWordTag *word = m_Tags.m_Words[ w ];
+
+
+		for ( int i = 0; i < word->m_Phonemes.Size(); i++ )
+		{
+			CPhonemeTag *pCurrent = word->m_Phonemes[ i ];
+
+			if ( time < pCurrent->GetStartTime() )
+				continue;
+
+			if ( time > pCurrent->GetEndTime() )
+				continue;
+
+			return pCurrent;
+		}
+	}
+
+	return NULL;
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+// Input  : phoneme - 
+//			startx - 
+//			endx - 
+//-----------------------------------------------------------------------------
+void PhonemeEditor::FinishPhonemeDrag( int startx, int endx )
+{
+	float clicktime	= GetTimeForPixel( startx );
+	float endtime	= GetTimeForPixel( endx );
+
+	float dt = endtime - clicktime;
+
+	SetDirty( true );
+
+	PushUndo();
+
+	TraversePhonemes( &PhonemeEditor::ITER_MoveSelectedPhonemes, dt );
+
+	RealignWordsToPhonemes( false );
+	CleanupWordsAndPhonemes( false );
+
+	PushRedo();
+
+	redraw();
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+// Input  : phoneme - 
+//			startx - 
+//			endx - 
+//-----------------------------------------------------------------------------
+void PhonemeEditor::FinishPhonemeMove( int startx, int endx )
+{
+	float clicktime	= GetTimeForPixel( startx );
+	float endtime	= GetTimeForPixel( endx );
+
+	// Find the phonemes who have the closest start/endtime to the starting click time
+	CPhonemeTag *current, *next;
+
+	if ( !FindSpanningPhonemes( clicktime, &current, &next ) )
+	{
+		return;
+	}
+
+	SetDirty( true );
+
+	PushUndo();
+
+	if ( current && !next )
+	{
+		// cap movement
+		current->AddEndTime( endtime - clicktime );
+	}
+	else if ( !current && next )
+	{
+		// cap movement
+		next->AddStartTime( endtime - clicktime );
+	}
+	else
+	{
+		// cap movement
+		endtime = min( endtime, next->GetEndTime() - 1.0f / GetPixelsPerSecond() );
+		endtime = max( endtime, current->GetStartTime() + 1.0f / GetPixelsPerSecond() );
+
+		current->SetEndTime( endtime );
+		next->SetStartTime( endtime );
+	}
+
+	RealignWordsToPhonemes( false );
+	CleanupWordsAndPhonemes( false );
+
+	PushRedo();
+
+	redraw();
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+// Input  : dirty - 
+//-----------------------------------------------------------------------------
+void PhonemeEditor::SetDirty( bool dirty, bool clearundo /*=true*/ )
+{
+	m_WorkFile.m_bDirty = dirty;
+
+	if ( !dirty && clearundo )
+	{
+		WipeUndo();
+		redraw();
+	}
+
+	SetPrefix( dirty ? "* " : "" );
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+// Output : Returns true on success, false on failure.
+//-----------------------------------------------------------------------------
+bool PhonemeEditor::GetDirty( void )
+{
+	return m_WorkFile.m_bDirty;
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+void PhonemeEditor::EditInsertPhonemeBefore( void )
+{
+	if ( GetMode() != MODE_PHONEMES )
+		return;
+
+	CPhonemeTag *cp = GetSelectedPhoneme();
+	if ( !cp )
+		return;
+
+	float gap = GetTimeGapToNextPhoneme( false, cp );
+	if ( gap < MINIMUM_PHONEME_GAP )
+	{
+		Con_Printf( "Can't insert before, gap of %.2f ms is too small\n", 1000.0f * gap );
+		return;
+	}
+
+	// Don't have really long phonemes
+	gap = min( gap, DEFAULT_PHONEME_LENGTH );
+
+	CWordTag *word = m_Tags.GetWordForPhoneme( cp );
+	if ( !word )
+	{
+		Con_Printf( "EditInsertPhonemeBefore:  phoneme not a member of any known word!!!\n" );
+		return;
+	}
+
+	int clicked = word->IndexOfPhoneme( cp );
+	if ( clicked < 0 )
+	{
+		Con_Printf( "EditInsertPhonemeBefore:  phoneme not a member of any specified word!!!\n" );
+		Assert( 0 );
+		return;
+	}
+
+	CPhonemeTag phoneme;
+
+	CPhonemeParams params;
+	memset( &params, 0, sizeof( params ) );
+	strcpy( params.m_szDialogTitle, "Phoneme/Viseme Properties" );
+	strcpy( params.m_szName, "" );
+
+	int iret = PhonemeProperties( &params );
+	SetFocus( (HWND)getHandle() );
+	if ( !iret )
+	{
+		return;
+	}
+
+	SetDirty( true );
+
+	PushUndo();
+
+	phoneme.SetPhonemeCode( TextToPhoneme( params.m_szName ) );
+	phoneme.SetTag( params.m_szName );
+
+	phoneme.SetEndTime( cp->GetStartTime() );
+	phoneme.SetStartTime( cp->GetStartTime() - gap );
+	phoneme.m_bSelected = true;
+	cp->m_bSelected = false;
+
+	word->m_Phonemes.InsertBefore( clicked, new CPhonemeTag( phoneme ) );
+
+	PushRedo();
+
+	// Add it
+	redraw();
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+void PhonemeEditor::EditInsertPhonemeAfter( void )
+{
+	if ( GetMode() != MODE_PHONEMES )
+		return;
+
+	CPhonemeTag *cp = GetSelectedPhoneme();
+	if ( !cp )
+		return;
+
+	float gap = GetTimeGapToNextPhoneme( true, cp );
+	if ( gap < MINIMUM_PHONEME_GAP )
+	{
+		Con_Printf( "Can't insert after, gap of %.2f ms is too small\n", 1000.0f * gap );
+		return;
+	}
+
+	// Don't have really long phonemes
+	gap = min( gap, DEFAULT_PHONEME_LENGTH );
+
+	CWordTag *word = m_Tags.GetWordForPhoneme( cp );
+	if ( !word )
+	{
+		Con_Printf( "EditInsertPhonemeAfter:  phoneme not a member of any known word!!!\n" );
+		return;
+	}
+
+	int clicked = word->IndexOfPhoneme( cp );
+	if ( clicked < 0 )
+	{
+		Con_Printf( "EditInsertPhonemeAfter:  phoneme not a member of any specified word!!!\n" );
+		Assert( 0 );
+		return;
+	}
+
+	CPhonemeTag phoneme;
+
+	CPhonemeParams params;
+	memset( &params, 0, sizeof( params ) );
+	strcpy( params.m_szDialogTitle, "Phoneme/Viseme Properties" );
+	strcpy( params.m_szName, "" );
+
+	int iret = PhonemeProperties( &params );
+	SetFocus( (HWND)getHandle() );
+
+	if ( !iret )
+	{
+		return;
+	}
+
+	SetDirty( true );
+
+	PushUndo();
+
+	phoneme.SetPhonemeCode( TextToPhoneme( params.m_szName ) );
+	phoneme.SetTag( params.m_szName );
+
+	phoneme.SetEndTime( cp->GetEndTime() + gap );
+	phoneme.SetStartTime( cp->GetEndTime() );
+	phoneme.m_bSelected = true;
+	cp->m_bSelected = false;
+	
+	word->m_Phonemes.InsertAfter( clicked, new CPhonemeTag( phoneme ) );
+
+	PushRedo();
+
+	// Add it
+	redraw();
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+void PhonemeEditor::EditInsertWordBefore( void )
+{
+	if ( GetMode() != MODE_PHONEMES )
+		return;
+
+	CWordTag *cw = GetSelectedWord();
+	if ( !cw )
+		return;
+
+	float gap = GetTimeGapToNextWord( false, cw );
+	if ( gap < MINIMUM_WORD_GAP )
+	{
+		Con_Printf( "Can't insert before, gap of %.2f ms is too small\n", 1000.0f * gap );
+		return;
+	}
+
+	// Don't have really long words
+	gap = min( gap, DEFAULT_WORD_LENGTH );
+
+	int clicked = IndexOfWord( cw );
+	if ( clicked < 0 )
+	{
+		Con_Printf( "EditInsertWordBefore:  word not in sentence!!!\n" );
+		Assert( 0 );
+		return;
+	}
+
+	CInputParams params;
+	memset( &params, 0, sizeof( params ) );
+	strcpy( params.m_szDialogTitle, "Insert Word" );
+	strcpy( params.m_szPrompt, "Word:" );
+	strcpy( params.m_szInputText, "" );
+
+	params.m_nLeft = -1;
+	params.m_nTop = -1;
+
+	params.m_bPositionDialog = true;
+	if ( params.m_bPositionDialog )
+	{
+		RECT rcWord;
+		GetWordRect( cw, rcWord );
+
+		// Convert to screen coords
+		POINT pt;
+		pt.x = rcWord.left;
+		pt.y = rcWord.top;
+
+		ClientToScreen( (HWND)getHandle(), &pt );
+
+		params.m_nLeft	= pt.x;
+		params.m_nTop	= pt.y;
+	}
+
+	int iret = InputProperties( &params );
+	SetFocus( (HWND)getHandle() );
+	if ( !iret )
+	{
+		return;
+	}
+
+	if ( strlen( params.m_szInputText ) <= 0 )
+	{
+		return;
+	}
+
+	int wordCount = CSentence::CountWords( params.m_szInputText );
+	if ( wordCount > 1 )
+	{
+		Con_Printf( "Can only insert one word at a time, %s has %i words in it!\n",
+			params.m_szInputText, wordCount );
+		return;
+	}
+
+	SetDirty( true );
+
+	PushUndo();
+
+	CWordTag newword;
+
+	newword.SetWord( params.m_szInputText );
+
+	newword.m_flEndTime		= cw->m_flStartTime;
+	newword.m_flStartTime	= cw->m_flStartTime - gap;
+	newword.m_bSelected = true;
+	cw->m_bSelected = false;
+
+	m_Tags.m_Words.InsertBefore( clicked, new CWordTag( newword ) );
+
+	PushRedo();
+
+	// Add it
+	redraw();
+
+	// Jump to phoneme insertion UI
+	EditInsertFirstPhonemeOfWord();
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+void PhonemeEditor::EditInsertWordAfter( void )
+{
+	if ( GetMode() != MODE_PHONEMES )
+		return;
+
+	CWordTag *cw = GetSelectedWord();
+	if ( !cw )
+		return;
+
+	float gap = GetTimeGapToNextWord( true, cw );
+	if ( gap < MINIMUM_WORD_GAP )
+	{
+		Con_Printf( "Can't insert after, gap of %.2f ms is too small\n", 1000.0f * gap );
+		return;
+	}
+
+	// Don't have really long words
+	gap = min( gap, DEFAULT_WORD_LENGTH );
+
+	int clicked = IndexOfWord( cw );
+	if ( clicked < 0 )
+	{
+		Con_Printf( "EditInsertWordBefore:  word not in sentence!!!\n" );
+		Assert( 0 );
+		return;
+	}
+
+	CInputParams params;
+	memset( &params, 0, sizeof( params ) );
+	strcpy( params.m_szDialogTitle, "Insert Word" );
+	strcpy( params.m_szPrompt, "Word:" );
+	strcpy( params.m_szInputText, "" );
+
+	params.m_nLeft = -1;
+	params.m_nTop = -1;
+
+	params.m_bPositionDialog = true;
+	if ( params.m_bPositionDialog )
+	{
+		RECT rcWord;
+		GetWordRect( cw, rcWord );
+
+		// Convert to screen coords
+		POINT pt;
+		pt.x = rcWord.left;
+		pt.y = rcWord.top;
+
+		ClientToScreen( (HWND)getHandle(), &pt );
+
+		params.m_nLeft	= pt.x;
+		params.m_nTop	= pt.y;
+	}
+
+	int iret = InputProperties( &params );
+	SetFocus( (HWND)getHandle() );
+	if ( !iret )
+	{
+		return;
+	}
+
+	if ( strlen( params.m_szInputText ) <= 0 )
+	{
+		return;
+	}
+
+	int wordCount = CSentence::CountWords( params.m_szInputText );
+	if ( wordCount > 1 )
+	{
+		Con_Printf( "Can only insert one word at a time, %s has %i words in it!\n",
+			params.m_szInputText, wordCount );
+		return;
+	}
+
+	SetDirty( true );
+
+	PushUndo();
+
+	CWordTag newword;
+
+	newword.SetWord( params.m_szInputText );
+
+	newword.m_flEndTime		= cw->m_flEndTime + gap;
+	newword.m_flStartTime	= cw->m_flEndTime;
+	newword.m_bSelected = true;
+	cw->m_bSelected = false;
+	
+	CWordTag *w = new CWordTag( newword );
+	Assert( w );
+	if ( w )
+	{
+		m_Tags.m_Words.InsertAfter( clicked, w );
+	}
+
+	PushRedo();
+
+	// Add it
+	redraw();
+
+	EditInsertFirstPhonemeOfWord();
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+void PhonemeEditor::EditDeletePhoneme( void )
+{
+	if ( GetMode() != MODE_PHONEMES )
+		return;
+
+	CountSelected();
+
+	if ( m_nSelectedPhonemeCount < 1 )
+	{
+		return;
+	}
+
+	SetDirty( true );
+
+	PushUndo();
+
+	for ( int i = m_Tags.m_Words.Size() - 1; i >= 0; i-- )
+	{
+		CWordTag *word = m_Tags.m_Words[ i ];
+		if ( !word )
+			continue;
+
+		for ( int j = word->m_Phonemes.Size() - 1; j >= 0; j-- )
+		{
+			CPhonemeTag *p = word->m_Phonemes[ j ];
+			if ( !p || !p->m_bSelected )
+				continue;
+
+			// Delete it
+			word->m_Phonemes.Remove( j );
+		}
+	}
+
+	PushRedo();
+
+	redraw();
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+void PhonemeEditor::EditDeleteWord( void )
+{
+	if ( GetMode() != MODE_PHONEMES )
+		return;
+
+	CountSelected();
+
+	if ( m_nSelectedWordCount < 1 )
+	{
+		return;
+	}
+
+	SetDirty( true );
+
+	PushUndo();
+
+	for ( int i = m_Tags.m_Words.Size() - 1; i >= 0; i-- )
+	{
+		CWordTag *word = m_Tags.m_Words[ i ];
+		if ( !word || !word->m_bSelected )
+			continue;
+
+		m_Tags.m_Words.Remove( i );
+	}
+
+	PushRedo();
+
+	redraw();
+}
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+void PhonemeEditor::PlayEditedWave( bool selection /* = false */ )
+{
+	StopPlayback();
+
+	if ( !m_pWaveFile )
+		return;
+
+	// Make sure phonemes are loaded
+	FacePoser_EnsurePhonemesLoaded();
+
+	SaveLinguisticData();
+
+	SetScrubTime( 0.0f );
+	SetScrubTargetTime( m_pWaveFile->GetRunningLength() );
+}
+
+typedef struct channel_s
+{
+	int		leftvol;
+	int		rightvol;
+	int		rleftvol;
+	int		rrightvol;
+	float	pitch;
+} channel_t;
+
+bool PhonemeEditor::CreateCroppedWave( char const *filename, int startsample, int endsample )
+{
+	Assert( sound );
+
+	CAudioWaveOutput *pWaveOutput = ( CAudioWaveOutput * )sound->GetAudioOutput();
+	if ( !pWaveOutput )
+		return false;
+
+	CAudioSource *wave = sound->LoadSound( m_WorkFile.m_szWaveFile );
+	if ( !wave )
+		return false;
+
+	CAudioMixer *pMixer = wave->CreateMixer();
+	if ( !pMixer )
+		return false;
+
+	// Create out put file
+	OutFileRIFF riffout( filename, io_out );
+	// Create output iterator
+	IterateOutputRIFF store( riffout );
+
+	WAVEFORMATEX format;
+	format.cbSize = sizeof( format );
+
+	format.wFormatTag = WAVE_FORMAT_PCM;
+	format.nAvgBytesPerSec = (int)wave->SampleRate();
+	format.nChannels = 1;
+	format.wBitsPerSample = 8;
+	format.nSamplesPerSec = (int)wave->SampleRate();
+	format.nBlockAlign = 1; // (int)wave->SampleSize();
+
+	store.ChunkWrite( WAVE_FMT, &format, sizeof( format ) );
+
+	// Pull in data and write it out
+
+	int currentsample = 0;
+
+	store.ChunkStart( WAVE_DATA );
+
+	// need a bit of space
+	short samples[ 2 ];
+	channel_t channel;
+	channel.leftvol = 255;
+	channel.rightvol = 255;
+	channel.pitch = 1.0;
+
+	while ( 1 )
+	{
+		pWaveOutput->m_audioDevice.MixBegin();
+
+		if ( !pMixer->MixDataToDevice( &pWaveOutput->m_audioDevice, &channel, currentsample, 1, wave->SampleRate(), true ) )
+			break;
+
+		pWaveOutput->m_audioDevice.TransferBufferStereo16( samples, 1 );
+
+		currentsample = pMixer->GetSamplePosition();
+
+		if ( currentsample >= startsample && currentsample <= endsample )
+		{
+			// left + right (2 channels ) * 16 bits
+			float s1 = (float)( samples[ 0 ] >> 8 );
+			float s2 = (float)( samples[ 1 ] >> 8 );
+
+			float avg = ( s1 + s2 ) / 2.0f;
+			unsigned char chopped = (unsigned char)( avg + 127.0f );
+
+			store.ChunkWriteData( &chopped, sizeof( byte ) );
+		}
+	}
+
+	store.ChunkFinish();
+
+	delete pMixer;
+	delete wave;
+
+	return true;
+}
+
+void PhonemeEditor::SentenceFromString( CSentence& sentence, char const *str )
+{
+	sentence.Reset();
+
+	if ( !str || !str[0] || CSentence::CountWords( str ) == 0 )
+	{
+		return;
+	}
+
+	char word[ 256 ];
+	unsigned char const *in = (unsigned char *)str;
+	char *out = word;
+	
+	while ( *in )
+	{
+		if ( *in > 32 )
+		{
+			*out++ = *in++;
+		}
+		else
+		{
+			*out = 0;
+
+			while ( *in && *in <= 32 )
+			{
+				in++;
+			}
+			
+			if ( strlen( word ) > 0 )
+			{
+				CWordTag *w = new CWordTag( (char *)word );
+				Assert( w );
+				if ( w )
+				{
+					sentence.m_Words.AddToTail( w );
+				}
+			}
+			
+			out = word;
+		}
+	}
+	
+	*out = 0;
+	if ( strlen( word ) > 0 )
+	{
+		CWordTag *w = new CWordTag( (char *)word );
+		Assert( w );
+		if ( w )
+		{
+			sentence.m_Words.AddToTail( w );
+		}
+	}
+	
+	sentence.SetText( str );
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+void PhonemeEditor::RedoPhonemeExtractionSelected( void )
+{
+	if ( GetMode() != MODE_PHONEMES )
+		return;
+
+	if ( !CheckSpeechAPI() )
+		return;
+
+	if ( !m_pWaveFile )
+	{
+		Con_Printf( "Can't redo extraction, no wavefile loaded!\n" );
+		Assert( 0 );
+		return;
+	}
+
+	if ( !m_bSelectionActive )
+	{
+		Con_Printf( "Please select a portion of the .wav from which to re-extract phonemes\n" );
+		return;
+	}
+
+	// Now copy data back into original list, offsetting by samplestart time
+	float numsamples = m_pWaveFile->GetRunningLength() * m_pWaveFile->SampleRate();
+	float selectionstarttime = 0.0f;
+	if ( numsamples > 0.0f )
+	{
+		// Convert sample #'s to time
+		selectionstarttime = ( m_nSelection[ 0 ] / numsamples ) * m_pWaveFile->GetRunningLength();
+		selectionstarttime = max( 0.0f, selectionstarttime );
+	}
+	else
+	{
+		Con_Printf( "Original .wav file %s has no samples!!!\n", m_WorkFile.m_szWaveFile );
+		return;
+	}
+
+	int i;
+	// Create input array of just selected words
+	CSentence m_InputWords;
+	CSentence m_Results;
+
+	CountSelected();
+	
+	bool usingselection = true;
+
+	if ( m_nSelectedWordCount == 0 )
+	{
+		// Allow user to type in text
+		// Build word string
+		char wordstring[ 1024 ];
+		strcpy( wordstring, "" );
+
+		CInputParams params;
+		memset( &params, 0, sizeof( params ) );
+		strcpy( params.m_szDialogTitle, "Phrase Word List" );
+		strcpy( params.m_szPrompt, "Phrase" );
+
+		strcpy( params.m_szInputText, wordstring );
+
+		if ( !InputProperties( &params ) )
+			return;
+
+		if ( strlen( params.m_szInputText ) <= 0 )
+		{
+			Con_ErrorPrintf( "Edit word list:  No words entered!\n" );
+			return;
+		}
+
+		SentenceFromString( m_InputWords, params.m_szInputText );
+
+		if ( m_InputWords.m_Words.Size() == 0 )
+		{
+			Con_Printf( "You must either select words, or type in a set of words in order to extract phonemes!\n" );
+			return;
+		}
+
+		usingselection = false;
+	}
+	else
+	{
+		if ( !AreSelectedWordsContiguous() )
+		{
+			Con_Printf( "Can only redo extraction on a contiguous subset of words\n" );
+			return;
+		}
+
+		char temp[ 4096 ];
+		bool killspace = false;
+		Q_strncpy( temp, m_InputWords.GetText(), sizeof( temp ) );
+
+		// Iterate existing words, looking for contiguous selected words
+		for ( i = 0; i < m_Tags.m_Words.Size(); i++ )
+		{
+			CWordTag *word = m_Tags.m_Words[ i ];
+			if ( !word || !word->m_bSelected )
+				continue;
+
+			// Now add "clean slate" to input list
+			m_InputWords.m_Words.AddToTail( new CWordTag( *word ) );
+
+			Q_strncat( temp, word->GetWord(), sizeof( temp ), COPY_ALL_CHARACTERS );
+			Q_strncat( temp, " ", sizeof( temp ), COPY_ALL_CHARACTERS );
+			killspace = true;
+		}
+
+		// Kill terminal space character
+		int len = Q_strlen( temp );
+		if ( killspace && ( len >= 1 ) )
+		{
+			Assert( temp[ len -1 ] == ' ' );
+			temp[ len - 1 ] = 0;
+		}
+
+		m_InputWords.SetText( temp );
+	}
+
+	m_nLastExtractionResult		= SR_RESULT_NORESULT;
+
+	char szCroppedFile[ 512 ];
+	char szBaseFile[ 512 ];
+	Q_StripExtension( m_WorkFile.m_szWaveFile, szBaseFile, sizeof( szBaseFile ) );
+	Q_snprintf( szCroppedFile, sizeof( szCroppedFile ), "%s%s_work1.wav", m_WorkFile.m_szBasePath, szBaseFile );
+
+	filesystem->RemoveFile( szCroppedFile, "GAME" );
+
+	if ( !CreateCroppedWave( szCroppedFile, m_nSelection[ 0 ], m_nSelection[ 1 ] ) )
+	{
+		Con_Printf( "Unable to create cropped wave file %s from samples %i to %i\n",
+			szCroppedFile,
+			m_nSelection[ 0 ],
+			m_nSelection[ 1 ] );
+		return;
+	}
+
+	CAudioSource *m_pCroppedWave = sound->LoadSound( szCroppedFile );
+	if ( !m_pCroppedWave )
+	{
+		Con_Printf( "Unable to load cropped wave file %s from samples %i to %i\n",
+			szCroppedFile,
+			m_nSelection[ 0 ],
+			m_nSelection[ 1 ] );
+		return;
+	}
+
+	// Save any pending stuff
+	SaveLinguisticData();
+
+	// Store off copy of complete sentence
+	m_TagsExt = m_Tags;
+
+	char filename[ 512 ];
+	Q_snprintf( filename, sizeof( filename ), "%s%s", m_WorkFile.m_szBasePath, szCroppedFile );
+
+	m_nLastExtractionResult = m_pPhonemeExtractor->Extract( 
+		filename,
+		(int)( m_pCroppedWave->GetRunningLength() * m_pCroppedWave->SampleRate() * m_pCroppedWave->TrueSampleSize() ),
+		Con_Printf,
+		m_InputWords,
+		m_Results );
+
+	if ( m_InputWords.m_Words.Size() != m_Results.m_Words.Size() )
+	{
+		Con_Printf( "Extraction returned %i words, source had %i, try adjusting selection\n",
+			m_Results.m_Words.Size(), m_InputWords.m_Words.Size() );
+
+		filesystem->RemoveFile( filename, "GAME" );
+
+		redraw();
+		return;
+	}
+
+	float bytespersecond = m_pCroppedWave->SampleRate() * m_pCroppedWave->TrueSampleSize();
+
+	// Tracker 57389:
+	// Total hack to fix a bug where the Lipsinc extractor is messing up the # channels on 16 bit stereo waves
+	if ( m_pPhonemeExtractor->GetAPIType() == SPEECH_API_LIPSINC &&
+		m_pCroppedWave->IsStereoWav() && 
+		m_pCroppedWave->SampleSize() == 16 )
+	{
+		bytespersecond *= 2.0f;
+	}
+
+	// Now convert byte offsets to times
+	for ( i = 0; i < m_Results.m_Words.Size(); i++ )
+	{
+		CWordTag *tag = m_Results.m_Words[ i ];
+		Assert( tag );
+		if ( !tag )
+			continue;
+
+		tag->m_flStartTime = ( float )(tag->m_uiStartByte ) / bytespersecond;
+		tag->m_flEndTime = ( float )(tag->m_uiEndByte ) / bytespersecond;
+
+		for ( int j = 0; j < tag->m_Phonemes.Size(); j++ )
+		{
+			CPhonemeTag *ptag = tag->m_Phonemes[ j ];
+			Assert( ptag );
+			if ( !ptag )
+				continue;
+
+			ptag->SetStartTime( ( float )(ptag->m_uiStartByte ) / bytespersecond );
+			ptag->SetEndTime( ( float )(ptag->m_uiEndByte ) / bytespersecond );
+		}
+	}
+
+	if ( usingselection )
+	{
+		// Copy data into m_TagsExt, offseting times by selectionstarttime
+		CWordTag *from;
+		CWordTag *to;
+
+		int fromWord = 0;
+
+		for ( i = 0; i < m_TagsExt.m_Words.Size() ; i++ )
+		{
+			to = m_TagsExt.m_Words[ i ];
+			if ( !to || !to->m_bSelected )
+				continue;
+
+			// Found start of contiguous run
+			if ( fromWord >= m_Results.m_Words.Size() )
+				break;
+
+			from = m_Results.m_Words[ fromWord++ ];
+			Assert( from );
+			if ( !from )
+				continue;
+
+			// Remove all phonemes from destination
+			while ( to->m_Phonemes.Size() > 0 )
+			{
+				CPhonemeTag *p = to->m_Phonemes[ 0 ];
+				Assert( p );
+				to->m_Phonemes.Remove( 0 );
+				delete p;
+			}
+
+			// Now copy phonemes from source
+			for ( int j = 0; j < from->m_Phonemes.Size(); j++ )
+			{
+				CPhonemeTag *fromPhoneme = from->m_Phonemes[ j ];
+				Assert( fromPhoneme );
+				if ( !fromPhoneme )
+					continue;
+
+				CPhonemeTag newPhoneme( *fromPhoneme );
+				// Offset start time
+				newPhoneme.AddStartTime( selectionstarttime );
+				newPhoneme.AddEndTime( selectionstarttime );
+
+				// Add it back in with corrected timing data
+				CPhonemeTag *p = new CPhonemeTag( newPhoneme );
+				Assert( p );
+				if ( p )
+				{
+					to->m_Phonemes.AddToTail( p );
+				}
+			}
+
+			// Done
+			if ( fromWord >= m_Results.m_Words.Size() )
+				break;
+		}
+
+	}
+	else
+	{
+		// Find word just before starting point of selection and
+		//  place input words into list starting that that point
+
+		int startWord = 0;
+
+		CWordTag *firstWordOfPhrase = m_Results.m_Words[ 0 ];
+		Assert( firstWordOfPhrase );
+		
+		for ( ; startWord < m_TagsExt.m_Words.Size(); startWord++ )
+		{
+			CWordTag *w = m_TagsExt.m_Words[ startWord ];
+			Assert( w );
+			if ( !w )
+				continue;
+			
+			if ( w->m_flStartTime > firstWordOfPhrase->m_flStartTime + selectionstarttime )
+				break;
+		}
+
+		for ( i = 0; i < m_Results.m_Words.Size(); i++ )
+		{
+			CWordTag *from = m_Results.m_Words[ i ];
+			Assert( from );
+			if ( !from )
+				continue;
+
+			CWordTag *to = new CWordTag( *from );
+			Assert( to );
+
+			to->m_flStartTime	+= selectionstarttime;
+			to->m_flEndTime		+= selectionstarttime;
+
+			// Now adjust phoneme times
+			for ( int j = 0; j < to->m_Phonemes.Size(); j++ )
+			{
+				CPhonemeTag *toPhoneme = to->m_Phonemes[ j ];
+				Assert( toPhoneme );
+				if ( !toPhoneme )
+					continue;
+
+				// Offset start time
+				toPhoneme->AddStartTime( selectionstarttime );
+				toPhoneme->AddEndTime( selectionstarttime );
+			}
+
+			m_TagsExt.m_Words.InsertBefore( startWord++, to );
+		}
+	}
+
+	Con_Printf( "Cleaning up...\n" );
+	filesystem->RemoveFile( filename, "GAME" );
+
+	SetFocus( (HWND)getHandle() );
+
+	redraw();
+}
+
+void PhonemeEditor::RedoPhonemeExtraction( void )
+{
+	if ( GetMode() != MODE_PHONEMES )
+		return;
+
+	if ( !CheckSpeechAPI() )
+		return;
+
+	m_nLastExtractionResult		= SR_RESULT_NORESULT;
+
+	if ( !m_pWaveFile )
+		return;
+
+	SaveLinguisticData();
+
+	// Send m_WorkFile.m_szWorkingFile to extractor and retrieve resulting data
+	// 
+
+	m_TagsExt.Reset();
+
+	Assert( m_pPhonemeExtractor );
+
+	char filename[ 512 ];
+	Q_snprintf( filename, sizeof( filename ), "%s%s", m_WorkFile.m_szBasePath, m_WorkFile.m_szWorkingFile );
+
+	m_nLastExtractionResult = m_pPhonemeExtractor->Extract( 
+		filename,
+		(int)( m_pWaveFile->GetRunningLength() * m_pWaveFile->SampleRate() * m_pWaveFile->TrueSampleSize() ),
+		Con_Printf,
+		m_Tags,
+		m_TagsExt );
+
+	float bytespersecond = m_pWaveFile->SampleRate() * m_pWaveFile->TrueSampleSize();
+
+	// Now convert byte offsets to times
+	int i;
+	for ( i = 0; i < m_TagsExt.m_Words.Size(); i++ )
+	{
+		CWordTag *tag = m_TagsExt.m_Words[ i ];
+		Assert( tag );
+		if ( !tag )
+			continue;
+
+		tag->m_flStartTime = ( float )(tag->m_uiStartByte ) / bytespersecond;
+		tag->m_flEndTime = ( float )(tag->m_uiEndByte ) / bytespersecond;
+
+		for ( int j = 0; j < tag->m_Phonemes.Size(); j++ )
+		{
+			CPhonemeTag *ptag = tag->m_Phonemes[ j ];
+			Assert( ptag );
+			if ( !ptag )
+				continue;
+
+			ptag->SetStartTime( ( float )(ptag->m_uiStartByte ) / bytespersecond );
+			ptag->SetEndTime( ( float )(ptag->m_uiEndByte ) / bytespersecond );
+		}
+	}
+
+	SetFocus( (HWND)getHandle() );
+
+	redraw();
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+void PhonemeEditor::Deselect( void )
+{
+	m_nSelection[ 0 ] = m_nSelection[ 1 ] = 0;
+	m_bSelectionActive = false;
+}
+
+void PhonemeEditor::ITER_SelectSpanningWords( CWordTag *word, float amount )
+{
+	Assert( word );
+	word->m_bSelected = false;
+
+	if ( !m_bSelectionActive )
+		return;
+
+	if ( !m_pWaveFile )
+		return;
+
+	float numsamples = m_pWaveFile->GetRunningLength() * m_pWaveFile->SampleRate();
+	if ( numsamples > 0.0f )
+	{
+		// Convert sample #'s to time
+		float starttime = ( m_nSelection[ 0 ] / numsamples ) * m_pWaveFile->GetRunningLength();
+		float endtime	= ( m_nSelection[ 1 ] / numsamples ) * m_pWaveFile->GetRunningLength();
+
+		if ( word->m_flEndTime >= starttime &&
+			 word->m_flStartTime <= endtime )
+		{
+			word->m_bSelected = true;
+
+			m_bWordsActive = true;
+		}
+	}
+}
+
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+// Input  : start - 
+//			end - 
+//-----------------------------------------------------------------------------
+void PhonemeEditor::SelectSamples( int start, int end )
+{
+	if ( !m_pWaveFile )
+		return;
+
+	// Make sure order is correct
+	if ( end < start )
+	{
+		int temp = end;
+		end = start;
+		start = temp;
+	}
+
+	Deselect();
+
+	m_nSelection[ 0 ] = start;
+	m_nSelection[ 1 ] = end;
+	m_bSelectionActive = true;
+
+	// Select any words that span the selection
+	//
+	TraverseWords( &PhonemeEditor::ITER_SelectSpanningWords, 0.0f );
+
+	redraw();
+}
+
+void PhonemeEditor::FinishMoveSelection( int startx, int mx )
+{
+	if ( !m_pWaveFile )
+		return;
+
+	int sampleStart = GetSampleForMouse( startx );
+	int sampleEnd = GetSampleForMouse( mx );
+
+	int delta = sampleEnd - sampleStart;
+
+	for ( int i = 0; i < 2; i++ )
+	{
+		m_nSelection[ i ] += delta;
+	}
+
+	// Select any words that span the selection
+	//
+	TraverseWords( &PhonemeEditor::ITER_SelectSpanningWords, 0.0f );
+
+	redraw();
+}
+
+void PhonemeEditor::FinishMoveSelectionStart( int startx, int mx )
+{
+	if ( !m_pWaveFile )
+		return;
+
+	int sampleStart = GetSampleForMouse( startx );
+	int sampleEnd = GetSampleForMouse( mx );
+
+	int delta = sampleEnd - sampleStart;
+
+	m_nSelection[ 0 ] += delta;
+
+	if ( m_nSelection[ 0 ] >= m_nSelection[ 1 ] )
+	{
+		Deselect();
+	}
+
+	// Select any words that span the selection
+	//
+	TraverseWords( &PhonemeEditor::ITER_SelectSpanningWords, 0.0f );
+
+	redraw();
+}
+
+void PhonemeEditor::FinishMoveSelectionEnd( int startx, int mx )
+{
+	if ( !m_pWaveFile )
+		return;
+
+	int sampleStart = GetSampleForMouse( startx );
+	int sampleEnd = GetSampleForMouse( mx );
+
+	int delta = sampleEnd - sampleStart;
+
+	m_nSelection[ 1 ] += delta;
+
+	if ( m_nSelection[ 1 ] <= m_nSelection[ 0 ] )
+	{
+		Deselect();
+	}
+
+	// Select any words that span the selection
+	//
+	TraverseWords( &PhonemeEditor::ITER_SelectSpanningWords, 0.0f );
+
+	redraw();
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+// Input  : startx - 
+//			mx - 
+//-----------------------------------------------------------------------------
+void PhonemeEditor::FinishSelect( int startx, int mx )
+{
+	if ( !m_pWaveFile )
+		return;
+
+	// Don't select really small areas
+	if ( abs( startx - mx ) < 2 )
+		return;
+
+	int sampleStart = GetSampleForMouse( startx );
+	int sampleEnd = GetSampleForMouse( mx );
+
+	SelectSamples( sampleStart, sampleEnd );
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+// Input  : mx - 
+//			my - 
+// Output : Returns true on success, false on failure.
+//-----------------------------------------------------------------------------
+bool PhonemeEditor::IsMouseOverSamples( int mx, int my )
+{
+	if ( GetMode() != MODE_PHONEMES )
+		return false;
+
+	// Deterime if phoneme boundary is under the cursor
+	//
+	if ( !m_pWaveFile )
+		return false;
+
+	RECT rc;
+	GetWorkspaceRect( rc );
+
+	// Over tag
+	if ( my >= TAG_TOP && my <= TAG_BOTTOM )
+		return false;
+
+	if ( IsMouseOverPhonemeRow( my ) )
+		return false;
+
+	if ( IsMouseOverWordRow( my ) )
+		return false;
+
+	RECT rcWord;
+	GetWordTrayTopBottom( rcWord );
+	RECT rcPhoneme;
+	GetPhonemeTrayTopBottom( rcPhoneme );
+
+	if ( my < rcWord.bottom )
+		return false;
+
+	if ( my > rcPhoneme.top )
+		return false;
+
+	return true;
+}
+
+void PhonemeEditor::GetScreenStartAndEndTime( float &starttime, float& endtime )
+{
+	starttime = m_nLeftOffset / GetPixelsPerSecond();
+	endtime = w2() / GetPixelsPerSecond() + starttime;
+}
+
+float PhonemeEditor::GetTimePerPixel( void )
+{
+	RECT rc;
+	GetWorkspaceRect( rc );
+
+	float starttime, endtime;
+	GetScreenStartAndEndTime( starttime, endtime );
+
+	if ( rc.right - rc.left <= 0 )
+	{
+		return ( endtime - starttime );
+	}
+
+	float timeperpixel = ( endtime - starttime ) / (float)( rc.right - rc.left );
+	return timeperpixel;
+}
+
+int PhonemeEditor::GetPixelForSample( int sample )
+{
+	RECT rc;
+	GetWorkspaceRect( rc );
+
+	if ( !m_pWaveFile )
+		return rc.left;
+
+	// Determine start/stop positions
+	int totalsamples = (int)( m_pWaveFile->GetRunningLength() * m_pWaveFile->SampleRate() );
+	if ( totalsamples <= 0 )
+	{
+		return rc.left;
+	}
+
+	float starttime, endtime;
+	GetScreenStartAndEndTime( starttime, endtime );
+
+	float sampleFrac = (float)sample / (float)totalsamples;
+	float sampleTime = sampleFrac * (float)m_pWaveFile->GetRunningLength();
+
+	if ( endtime - starttime < 0.0f )
+	{
+		return rc.left;
+	}
+
+	float windowFrac = ( sampleTime - starttime ) / ( endtime - starttime );
+
+	return rc.left + (int)( windowFrac * ( rc.right - rc.left ) );
+}
+
+int PhonemeEditor::GetSampleForMouse( int mx )
+{
+	if ( !m_pWaveFile )
+		return 0;
+
+	RECT rc;
+	GetWorkspaceRect( rc );
+
+	// Determine start/stop positions
+	int totalsamples = (int)( m_pWaveFile->GetRunningLength() * m_pWaveFile->SampleRate() );
+
+	float starttime, endtime;
+	GetScreenStartAndEndTime( starttime, endtime );
+
+	if ( GetPixelsPerSecond() <= 0 )
+		return 0;
+
+	// Start and end times
+	float clickTime	= (float)mx / GetPixelsPerSecond() + starttime;
+
+	// What sample do these correspond to
+	if ( (float)m_pWaveFile->GetRunningLength() <= 0.0f )
+		return 0;
+
+	int sampleNumber	= (int) ( (float)totalsamples * clickTime / (float)m_pWaveFile->GetRunningLength() );
+
+	return sampleNumber;
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+// Input  : mx - 
+//			my - 
+// Output : Returns true on success, false on failure.
+//-----------------------------------------------------------------------------
+bool PhonemeEditor::IsMouseOverSelection( int mx, int my )
+{
+	if ( GetMode() != MODE_PHONEMES )
+		return false;
+
+	if ( !m_pWaveFile )
+		return false;
+
+	if ( !m_bSelectionActive )
+		return false;
+
+	if ( !IsMouseOverSamples( mx, my ) )
+		return false;
+
+	int sampleNumber = GetSampleForMouse( mx );
+
+	if ( sampleNumber >= m_nSelection[ 0 ] - 3 &&
+		 sampleNumber <= m_nSelection[ 1 ] + 3 )
+	{
+		return true;
+	}
+
+	return false;
+}
+
+bool PhonemeEditor::IsMouseOverSelectionStartEdge( mxEvent *event )
+{
+	if ( GetMode() != MODE_PHONEMES )
+		return false;
+
+	if ( !m_pWaveFile )
+		return false;
+
+	int mx, my;
+	mx = (short)event->x;
+	my = (short)event->y;
+
+	if ( !(event->modifiers & mxEvent::KeyCtrl ) )
+		return false;
+
+	if ( !IsMouseOverSelection( mx, my ) )
+		return false;
+
+	int sample = GetSampleForMouse( mx );
+
+	int		mouse_tolerance = 5;
+
+	RECT rc;
+	GetWorkspaceRect( rc );
+
+	// Determine start/stop positions
+	float timeperpixel = GetTimePerPixel();
+
+	int samplesperpixel = (int)( timeperpixel * m_pWaveFile->SampleRate() );
+
+	if ( abs( sample - m_nSelection[ 0 ] ) < mouse_tolerance * samplesperpixel )
+	{
+		return true;
+	}
+	return false;
+}
+
+bool PhonemeEditor::IsMouseOverSelectionEndEdge( mxEvent *event )
+{
+	if ( GetMode() != MODE_PHONEMES )
+		return false;
+
+	if ( !m_pWaveFile )
+		return false;
+
+	int mx, my;
+	mx = (short)event->x;
+	my = (short)event->y;
+
+	if ( !(event->modifiers & mxEvent::KeyCtrl ) )
+		return false;
+
+	if ( !IsMouseOverSelection( mx, my ) )
+		return false;
+
+	int sample = GetSampleForMouse( mx );
+
+	int		mouse_tolerance = 5;
+
+	RECT rc;
+	GetWorkspaceRect( rc );
+
+	if ( GetPixelsPerSecond() <= 0.0f )
+		return false;
+
+	if ( ( rc.right - rc.left ) <= 0 )
+		return false;
+
+	// Determine start/stop positions
+	float starttime = m_nLeftOffset / GetPixelsPerSecond();
+	float endtime = w2() / GetPixelsPerSecond() + starttime;
+
+	float timeperpixel = ( endtime - starttime ) / (float)( rc.right - rc.left );
+	int samplesperpixel = (int)( timeperpixel * m_pWaveFile->SampleRate() );
+
+	if ( abs( sample - m_nSelection[ 1 ] ) < mouse_tolerance * samplesperpixel )
+	{
+		return true;
+	}
+	return false;
+}
+
+void PhonemeEditor::OnImport()
+{
+	char filename[ 512 ];
+	if ( !FacePoser_ShowOpenFileNameDialog( filename, sizeof( filename ), "sound", "*" WORD_DATA_EXTENSION ) )
+	{
+		return;
+	}
+
+	ImportValveDataChunk( filename );
+}
+
+void PhonemeEditor::OnExport()
+{
+	if ( !m_pWaveFile )
+		return;
+
+	char filename[ 512 ];
+	if ( !FacePoser_ShowSaveFileNameDialog( filename, sizeof( filename ), "sound", "*" WORD_DATA_EXTENSION ) )
+	{
+		return;
+	}
+
+	Q_SetExtension( filename, WORD_DATA_EXTENSION, sizeof( filename ) );
+
+	ExportValveDataChunk( filename );
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+// Input  : store - 
+//-----------------------------------------------------------------------------
+void PhonemeEditor::StoreValveDataChunk( IterateOutputRIFF& store )
+{
+	// Buffer and dump data
+	CUtlBuffer buf( 0, 0, CUtlBuffer::TEXT_BUFFER );
+
+	m_Tags.SaveToBuffer( buf );
+
+	// Copy into store
+	store.ChunkWriteData( buf.Base(), buf.TellPut() );
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+// Input  : *tempfile - 
+//-----------------------------------------------------------------------------
+void PhonemeEditor::ExportValveDataChunk( char const *tempfile )
+{
+	if ( m_Tags.m_Words.Count() <= 0 )
+	{
+		Con_ErrorPrintf( "PhonemeEditor::ExportValveDataChunk:  Sentence has no word data\n" );
+		return;
+	}
+
+	FileHandle_t fh = filesystem->Open( tempfile, "wb" );
+	if ( !fh )
+	{
+		Con_ErrorPrintf( "PhonemeEditor::ExportValveDataChunk:  Unable to write to %s (read-only?)\n", tempfile );
+		return;
+	}
+	else
+	{
+		// Buffer and dump data
+		CUtlBuffer buf( 0, 0, CUtlBuffer::TEXT_BUFFER );
+
+		m_Tags.SaveToBuffer( buf );
+
+		filesystem->Write( buf.Base(), buf.TellPut(), fh );
+		filesystem->Close(fh);
+
+		Con_Printf( "Exported %i words to %s\n", m_Tags.m_Words.Count(), tempfile );
+	}
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+// Input  : *tempfile - 
+//-----------------------------------------------------------------------------
+void PhonemeEditor::ImportValveDataChunk( char const *tempfile )
+{
+	FileHandle_t fh = filesystem->Open( tempfile, "rb" );
+	if ( !fh )
+	{
+		Con_ErrorPrintf( "PhonemeEditor::ImportValveDataChunk:  Unable to read from %s\n", tempfile );
+		return;
+	}
+
+	int len = filesystem->Size( fh );
+	if ( len <= 4 )
+	{
+		Con_ErrorPrintf( "PhonemeEditor::ImportValveDataChunk:  File %s has length 0\n", tempfile );
+		return;
+	}
+
+	ClearExtracted();
+
+	unsigned char *buf = new unsigned char[ len + 1 ];
+
+	filesystem->Read( buf, len, fh );
+	filesystem->Close( fh );
+
+	m_TagsExt.InitFromDataChunk( (void *)( buf ), len );
+
+	delete[] buf;
+
+	Con_Printf( "Imported %i words from %s\n", m_TagsExt.m_Words.Count(), tempfile );
+
+	redraw();
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: Copy file over, but update phoneme lump with new data
+//-----------------------------------------------------------------------------
+void PhonemeEditor::SaveLinguisticData( void )
+{
+	if ( !m_pWaveFile )
+		return;
+
+	InFileRIFF riff( m_WorkFile.m_szWaveFile, io_in );
+	Assert( riff.RIFFName() == RIFF_WAVE );
+
+	// set up the iterator for the whole file (root RIFF is a chunk)
+	IterateRIFF walk( riff, riff.RIFFSize() );
+
+	char fullout[ 512 ];
+	Q_snprintf( fullout, sizeof( fullout ), "%s%s", m_WorkFile.m_szBasePath, m_WorkFile.m_szWorkingFile );
+
+	OutFileRIFF riffout( fullout, io_out );
+
+	IterateOutputRIFF store( riffout );
+
+	bool formatset = false;
+	WAVEFORMATEX format;
+
+	bool wordtrackwritten = false;
+
+	// Walk input chunks and copy to output
+	while ( walk.ChunkAvailable() )
+	{
+		unsigned int originalPos = store.ChunkGetPosition();
+
+		store.ChunkStart( walk.ChunkName() );
+
+		bool skipchunk = false;
+
+		switch ( walk.ChunkName() )
+		{
+		case WAVE_VALVEDATA:
+			// Overwrite data
+			StoreValveDataChunk( store );
+			wordtrackwritten = true;
+			break;
+		case WAVE_FMT:
+			{
+				formatset = true;
+				
+				char *buffer = new char[ walk.ChunkSize() ];
+				Assert( buffer );
+				walk.ChunkRead( buffer );
+
+				format = *(WAVEFORMATEX *)buffer;
+
+				store.ChunkWriteData( buffer, walk.ChunkSize() );
+
+				delete[] buffer;
+			}
+			break;
+		case WAVE_DATA:
+			{
+				Assert( formatset );
+				
+				char *buffer = new char[ walk.ChunkSize() ];
+				Assert( buffer );
+				
+				walk.ChunkRead( buffer );
+				// Resample it
+				ResampleChunk( store, (void *)&format, walk.ChunkName(), buffer, walk.ChunkSize() );
+
+				delete[] buffer;
+			}
+			break;
+		default:
+			store.CopyChunkData( walk );
+			break;
+		}
+
+		store.ChunkFinish();
+		if ( skipchunk )
+		{
+			store.ChunkSetPosition( originalPos );
+		}
+
+		walk.ChunkNext();
+	}
+
+	if ( !wordtrackwritten )
+	{
+		store.ChunkStart( WAVE_VALVEDATA );
+		StoreValveDataChunk( store );
+		store.ChunkFinish();
+	}
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: Copy phoneme data in from wave file we sent for resprocessing
+//-----------------------------------------------------------------------------
+void PhonemeEditor::RetrieveLinguisticData( void )
+{
+	if ( !m_pWaveFile )
+		return;
+
+	m_Tags.Reset();
+
+	ReadLinguisticTags();
+
+	redraw();
+}
+
+bool PhonemeEditor::StopPlayback( void )
+{
+	bool bret = false;
+	if ( m_pWaveFile )
+	{
+		SetScrubTargetTime( m_flScrub );
+
+		if ( sound->IsSoundPlaying( m_pMixer ) )
+		{
+			sound->StopAll();
+			bret = true;
+		}
+	}
+
+	sound->Flush();
+
+	return bret;
+}
+
+CPhonemeTag *PhonemeEditor::GetPhonemeTagUnderMouse( int mx, int my )
+{
+	if ( GetMode() != MODE_PHONEMES )
+		return NULL;
+
+	if ( !m_pWaveFile )
+		return NULL;
+
+	// FIXME:  Don't read from file, read from arrays after LISET finishes
+	// Deterime if phoneme boundary is under the cursor
+	//
+	RECT rc;
+	GetWorkspaceRect( rc );
+
+	if ( !IsMouseOverPhonemeRow( my ) )
+		return NULL;
+
+	if ( GetPixelsPerSecond() <= 0 )
+		return NULL;
+
+	float starttime = m_nLeftOffset / GetPixelsPerSecond();
+	float endtime = w2() / GetPixelsPerSecond() + starttime;
+
+	if ( endtime - starttime <= 0.0f )
+		return NULL;
+
+	for ( int i = 0; i < m_Tags.m_Words.Size(); i++ )
+	{
+		CWordTag *word = m_Tags.m_Words[ i ];
+		Assert( word );
+		if ( !word )
+			continue;
+
+		for ( int k = 0; k < word->m_Phonemes.Size(); k++ )
+		{
+			CPhonemeTag *pPhoneme = word->m_Phonemes[ k ];
+			Assert( pPhoneme );
+			if ( !pPhoneme )
+				continue;
+
+			float t1 = pPhoneme->GetStartTime();
+			float t2 = pPhoneme->GetEndTime();
+
+			float frac1 = ( t1 - starttime ) / ( endtime - starttime );
+			float frac2 = ( t2 - starttime ) / ( endtime - starttime );
+
+			frac1 = min( 1.0f, frac1 );
+			frac1 = max( 0.0f, frac1 );
+			frac2 = min( 1.0f, frac2 );
+			frac2 = max( 0.0f, frac2 );
+
+			if ( frac1 == frac2 )
+				continue;
+
+			int x1 = ( int )( frac1 * w2() );
+			int x2 = ( int )( frac2 * w2() );
+
+			if ( mx >= x1 && mx <= x2 )
+			{
+				return pPhoneme;
+			}
+		}
+	}
+
+	return NULL;
+}
+
+CWordTag *PhonemeEditor::GetWordTagUnderMouse( int mx, int my )
+{
+	if ( GetMode() != MODE_PHONEMES )
+		return NULL;
+
+	// Deterime if phoneme boundary is under the cursor
+	//
+	if ( !m_pWaveFile )
+		return NULL;
+
+	RECT rc;
+	GetWorkspaceRect( rc );
+
+	if ( !IsMouseOverWordRow( my ) )
+		return NULL;
+
+	if ( GetPixelsPerSecond() <= 0 )
+		return NULL;
+
+	float starttime = m_nLeftOffset / GetPixelsPerSecond();
+	float endtime = w2() / GetPixelsPerSecond() + starttime;
+
+	if ( endtime - starttime <= 0.0f )
+		return NULL;
+
+	for ( int k = 0; k < m_Tags.m_Words.Size(); k++ )
+	{
+		CWordTag *word = m_Tags.m_Words[ k ];
+		Assert( word );
+		if ( !word )
+			continue;
+
+		float t1 = word->m_flStartTime;
+		float t2 = word->m_flEndTime;
+
+		float frac1 = ( t1 - starttime ) / ( endtime - starttime );
+		float frac2 = ( t2 - starttime ) / ( endtime - starttime );
+
+		frac1 = min( 1.0f, frac1 );
+		frac1 = max( 0.0f, frac1 );
+		frac2 = min( 1.0f, frac2 );
+		frac2 = max( 0.0f, frac2 );
+
+		if ( frac1 == frac2 )
+			continue;
+
+		int x1 = ( int )( frac1 * w2() );
+		int x2 = ( int )( frac2 * w2() );
+
+		if ( mx >= x1 && mx <= x2 )
+		{
+			return word;
+		}
+	}
+
+	return NULL;
+}
+
+void PhonemeEditor::DeselectWords( void )
+{
+	if ( GetMode() != MODE_PHONEMES )
+		return;
+
+	for ( int i = 0 ; i < m_Tags.m_Words.Size(); i++ )
+	{
+		CWordTag *w = m_Tags.m_Words[ i ];
+		Assert( w );
+		if ( !w )
+			continue;
+		w->m_bSelected = false;
+	}
+
+}
+
+void PhonemeEditor::DeselectPhonemes( void )
+{
+	if ( GetMode() != MODE_PHONEMES )
+		return;
+
+	for ( int w = 0 ; w < m_Tags.m_Words.Size(); w++ )
+	{
+		CWordTag *word = m_Tags.m_Words[ w ];
+		Assert( word );
+		if ( !word )
+			continue;
+
+		for ( int i = 0 ; i < word->m_Phonemes.Size(); i++ )
+		{
+			CPhonemeTag *pt = word->m_Phonemes[ i ];
+			Assert( pt );
+			if ( !pt )
+				continue;
+			pt->m_bSelected = false;
+		}
+	}
+}
+
+void PhonemeEditor::SnapWords( void )
+{
+	if ( GetMode() != MODE_PHONEMES )
+		return;
+
+	if ( m_Tags.m_Words.Size() < 2 )
+	{
+		Con_Printf( "Can't snap, need at least two contiguous selected words\n" );
+		return;
+	}
+
+	SetDirty( true );
+
+	PushUndo();
+
+	for ( int i = 0; i < m_Tags.m_Words.Size() - 1; i++ )
+	{
+		CWordTag *current = m_Tags.m_Words[ i ];
+		CWordTag *next = m_Tags.m_Words[ i + 1 ];
+
+		Assert( current && next );
+
+		if ( !current->m_bSelected || !next->m_bSelected )
+			continue;
+
+		// Move next word to end of current
+		next->m_flStartTime = current->m_flEndTime;
+	}
+
+	PushRedo();
+
+	redraw();
+}
+
+void PhonemeEditor::SeparateWords( void )
+{
+	if ( GetMode() != MODE_PHONEMES )
+		return;
+
+	if ( GetPixelsPerSecond() <= 0.0f )
+		return;
+
+	if ( m_Tags.m_Words.Size() < 2 )
+	{
+		Con_Printf( "Can't separate, need at least two contiguous selected words\n" );
+		return;
+	}
+
+	// Three pixels
+	double time_epsilon = ( 1.0f / GetPixelsPerSecond() ) * 6;
+
+	SetDirty( true );
+
+	PushUndo();
+
+	for ( int i = 0; i < m_Tags.m_Words.Size() - 1; i++ )
+	{
+		CWordTag *current = m_Tags.m_Words[ i ];
+		CWordTag *next = m_Tags.m_Words[ i + 1 ];
+
+		Assert( current && next );
+
+		if ( !current->m_bSelected || !next->m_bSelected )
+			continue;
+
+		// Close enough?
+		if ( fabs( current->m_flEndTime - next->m_flStartTime ) > time_epsilon )
+		{
+			Con_Printf( "Can't split %s and %s, already split apart\n",
+				current->GetWord(), next->GetWord() );
+			continue;
+		}
+
+		// Offset next word start time a bit
+		next->m_flStartTime += time_epsilon;
+
+		break;
+	}
+
+	PushRedo();
+
+	redraw();
+}
+
+void PhonemeEditor::CreateEvenWordDistribution( const char *wordlist )
+{
+	if ( GetMode() != MODE_PHONEMES )
+		return;
+
+	if( !m_pWaveFile )
+		return;
+
+	Assert( wordlist );
+	if ( !wordlist )
+		return;
+
+	m_Tags.CreateEventWordDistribution( wordlist, m_pWaveFile->GetRunningLength() );
+
+	redraw();
+}
+
+void PhonemeEditor::EditWordList( void )
+{
+	if ( GetMode() != MODE_PHONEMES )
+		return;
+
+	if ( !m_pWaveFile )
+		return;
+
+	// Build word string
+	char wordstring[ 1024 ];
+	V_strcpy_safe( wordstring, m_Tags.GetText() );
+
+	CInputParams params;
+	memset( &params, 0, sizeof( params ) );
+	strcpy( params.m_szDialogTitle, "Word List" );
+	strcpy( params.m_szPrompt, "Sentence:" );
+
+	strcpy( params.m_szInputText, wordstring );
+
+	if ( !InputProperties( &params ) )
+		return;
+
+	if ( strlen( params.m_szInputText ) <= 0 )
+	{
+		// Could be foreign language...
+		Warning( "Edit word list:  No words entered!\n" );
+	}
+
+	SetDirty( true );
+
+	PushUndo();
+
+	// Clear any current LISET results
+	ClearExtracted();
+
+	// Force text
+	m_Tags.SetText( params.m_szInputText );
+
+	if ( m_Tags.m_Words.Size() == 0 )
+	{
+		// First text we've seen, just distribute words evenly
+		CreateEvenWordDistribution( params.m_szInputText );
+	
+		// Redo liset
+		RedoPhonemeExtraction();
+	}
+	
+	PushRedo();
+
+	SetFocus( (HWND)getHandle() );
+
+	redraw();
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: Overwrite original wave with changes
+//-----------------------------------------------------------------------------
+void PhonemeEditor::CommitChanges( void )
+{
+	SaveLinguisticData();
+
+	// Make it writable - if possible
+	MakeFileWriteable( m_WorkFile.m_szWaveFile );
+
+	//Open a message box to warn the user if the file was unable to be made non-read only
+	if ( !IsFileWriteable( m_WorkFile.m_szWaveFile ) )
+	{
+		mxMessageBox( NULL, va( "Unable to save file '%s'. File is read-only or in use.",	
+				m_WorkFile.m_szWaveFile ), g_appTitle, MX_MB_OK );
+	}
+	else
+	{
+		// Copy over and overwrite file
+		FPCopyFile( m_WorkFile.m_szWorkingFile, m_WorkFile.m_szWaveFile, true );
+		Msg( "Changes saved to '%s'\n", m_WorkFile.m_szWaveFile );
+		SetDirty( false, false );
+	}
+
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+void PhonemeEditor::LoadWaveFile( void )
+{
+	char filename[ 512 ];
+	if ( !FacePoser_ShowOpenFileNameDialog( filename, sizeof( filename ), "sound", "*.wav" ) )
+	{
+		return;
+	}
+
+	StopPlayback();
+
+	// Strip out the game directory
+	SetCurrentWaveFile( filename );
+}
+
+void PhonemeEditor::SnapPhonemes( void )
+{
+	if ( GetMode() != MODE_PHONEMES )
+		return;
+
+	SetDirty( true );
+
+	PushUndo();
+
+	CPhonemeTag *prev = NULL;
+
+	for ( int w = 0; w < m_Tags.m_Words.Size(); w++ )
+	{
+		CWordTag *word = m_Tags.m_Words[ w ];
+		Assert( word );
+		if ( !word )
+			continue;
+
+		for ( int i = 0; i < word->m_Phonemes.Size(); i++ )
+		{
+			CPhonemeTag *current = word->m_Phonemes[ i ];
+			
+			Assert( current );
+
+			if ( current->m_bSelected )
+			{
+				if (prev)
+				{
+					// More start of next to end of previous
+					prev->SetEndTime( current->GetStartTime() );
+				}
+				prev = current;
+			}
+			else
+			{
+				prev = NULL;
+			}
+		}
+	}
+
+	PushRedo();
+
+	redraw();
+}
+
+void PhonemeEditor::SeparatePhonemes( void )
+{
+	if ( GetMode() != MODE_PHONEMES )
+		return;
+
+	SetDirty( true );
+
+	PushUndo();
+
+	// Three pixels
+	double time_epsilon = ( 1.0f / GetPixelsPerSecond() ) * 6;
+
+	CPhonemeTag *prev = NULL;
+
+	for ( int w = 0; w < m_Tags.m_Words.Size(); w++ )
+	{
+		CWordTag *word = m_Tags.m_Words[ w ];
+		Assert( word );
+		if ( !word )
+			continue;
+
+		for ( int i = 0; i < word->m_Phonemes.Size(); i++ )
+		{
+			CPhonemeTag *current = word->m_Phonemes[ i ];
+
+			Assert( current );
+
+			if ( current->m_bSelected )
+			{
+				if ( prev )
+				{
+					// Close enough?
+					if ( fabs( prev->GetEndTime() - current->GetStartTime() ) > time_epsilon )
+					{
+						Con_Printf( "Can't split already split apart\n" );
+						continue;
+					}
+
+					current->AddStartTime( time_epsilon );
+				}
+
+				prev = current;
+			}
+			else
+			{
+				prev = NULL;
+			}
+		}
+	}
+
+	PushRedo();
+
+	redraw();
+}
+
+bool PhonemeEditor::IsMouseOverWordRow( int my )
+{
+	if ( GetMode() != MODE_PHONEMES )
+		return false;
+
+	RECT rc;
+
+	GetWordTrayTopBottom( rc );
+
+	if ( my < rc.top )
+		return false;
+	
+	if ( my > rc.bottom )
+		return false;
+	
+	return true;
+}
+
+bool PhonemeEditor::IsMouseOverPhonemeRow( int my )
+{
+	if ( GetMode() != MODE_PHONEMES )
+		return false;
+
+	RECT rc;
+
+	GetPhonemeTrayTopBottom( rc );
+
+	if ( my < rc.top )
+		return false;
+	
+	if ( my > rc.bottom )
+		return false;
+	
+	return true;
+}
+
+void PhonemeEditor::GetPhonemeTrayTopBottom( RECT& rc )
+{
+	RECT wkrc;
+	GetWorkspaceRect( wkrc );
+
+	rc.top  = wkrc.bottom - 2 * m_nTickHeight;
+	rc.bottom = wkrc.bottom - m_nTickHeight;
+}
+
+void PhonemeEditor::GetWordTrayTopBottom( RECT& rc )
+{
+	RECT wkrc;
+	GetWorkspaceRect( wkrc );
+
+	rc.top  = wkrc.top;
+	rc.bottom = wkrc.top + m_nTickHeight;
+}
+
+int PhonemeEditor::GetMouseForTime( float time )
+{
+	RECT rc;
+	GetWorkspaceRect( rc );
+
+	if ( GetPixelsPerSecond() < 0.0f )
+		return rc.left;
+
+	float starttime = m_nLeftOffset / GetPixelsPerSecond();
+	float endtime = w2() / GetPixelsPerSecond() + starttime;
+
+	if ( endtime - starttime <= 0.0f )
+		return rc.left;
+
+	float frac;
+
+	frac = ( time - starttime ) / ( endtime - starttime );
+
+	return rc.left + ( int )( rc.right * frac );
+}
+
+void PhonemeEditor::GetWordRect( const CWordTag *tag, RECT& rc )
+{
+	Assert( tag );
+	GetWordTrayTopBottom( rc );
+	
+	rc.left = GetMouseForTime( tag->m_flStartTime );
+	rc.right = GetMouseForTime( tag->m_flEndTime );
+
+}
+
+void PhonemeEditor::GetPhonemeRect( const CPhonemeTag *tag, RECT& rc )
+{
+	Assert( tag );
+
+	GetPhonemeTrayTopBottom( rc );
+	rc.left = GetMouseForTime( tag->GetStartTime() );
+	rc.right = GetMouseForTime( tag->GetEndTime() );
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+void PhonemeEditor::CommitExtracted( void )
+{
+	if ( GetMode() != MODE_PHONEMES )
+		return;
+
+	m_nLastExtractionResult		= SR_RESULT_NORESULT;
+
+	if ( !m_TagsExt.m_Words.Size() )
+		return;
+
+	SetDirty( true );
+
+	PushUndo();
+
+	m_Tags.Reset();
+	m_Tags = m_TagsExt;
+
+	PushRedo();
+
+	ClearExtracted();
+
+	redraw();
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+void PhonemeEditor::ClearExtracted( void )
+{
+	if ( GetMode() != MODE_PHONEMES )
+		return;
+
+	m_nLastExtractionResult		= SR_RESULT_NORESULT;
+
+	m_TagsExt.Reset();
+
+	redraw();
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+// Input  : resultCode - 
+// Output : const char
+//-----------------------------------------------------------------------------
+const char *PhonemeEditor::GetExtractionResultString( int resultCode )
+{
+	switch ( resultCode )
+	{
+	case SR_RESULT_NORESULT:
+		return "no extraction info.";
+	case SR_RESULT_ERROR:
+		return "an error occurred during extraction.";
+	case SR_RESULT_SUCCESS:
+		return "successful.";
+	case SR_RESULT_FAILED:
+		return "results retrieved, but full recognition failed.";
+	default:
+		break;
+	}
+
+	return "unknown result code.";
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+// Input  : mx - 
+// Output : CEventRelativeTag
+//-----------------------------------------------------------------------------
+CEventRelativeTag *PhonemeEditor::GetTagUnderMouse( int mx )
+{
+	if ( GetMode() != MODE_PHONEMES )
+		return NULL;
+
+	// Figure out tag positions
+	if ( !m_pEvent || !m_pWaveFile )
+		return NULL;
+	
+	RECT rc;
+	GetWorkspaceRect( rc );
+	RECT rcTags = rc;
+
+	if ( GetPixelsPerSecond() <= 0.0f )
+		return NULL;
+
+	float starttime = m_nLeftOffset / GetPixelsPerSecond();
+	float endtime = w2() / GetPixelsPerSecond() + starttime;
+
+	if ( endtime - starttime < 0 )
+		return NULL;
+
+	for ( int i = 0; i < m_pEvent->GetNumRelativeTags(); i++ )
+	{
+		CEventRelativeTag *tag = m_pEvent->GetRelativeTag( i );
+		if ( !tag )
+			continue;
+
+		// 
+		float tagtime = tag->GetPercentage() * m_pWaveFile->GetRunningLength();
+		if ( tagtime < starttime || tagtime > endtime )
+			continue;
+
+		float frac = ( tagtime - starttime ) / ( endtime - starttime );
+
+		int left = rcTags.left + (int)( frac * ( float )( rcTags.right - rcTags.left ) + 0.5f );
+
+		if ( abs( mx - left ) < 10 )
+			return tag;
+	}
+	return NULL;
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+// Input  : mx - 
+//			my - 
+// Output : Returns true on success, false on failure.
+//-----------------------------------------------------------------------------
+bool PhonemeEditor::IsMouseOverTag( int mx, int my )
+{
+	if ( GetMode() != MODE_PHONEMES )
+		return false;
+
+	if ( !IsMouseOverTagRow( my ) )
+		return false;
+
+	CEventRelativeTag *tag = GetTagUnderMouse( mx );
+	if ( !tag )
+		return false;
+
+	return true;
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+// Input  : startx - 
+//			endx - 
+//-----------------------------------------------------------------------------
+void PhonemeEditor::FinishEventTagDrag( int startx, int endx )
+{
+	if ( !m_pWaveFile )
+		return;
+
+	if ( !m_pWaveFile->GetRunningLength() )
+		return;
+
+	// Find starting tag
+	CEventRelativeTag *tag = GetTagUnderMouse( startx );
+	if ( !tag )
+		return;
+
+	if ( GetPixelsPerSecond() <= 0 )
+		return;
+
+	// Convert mouse position to time
+	float starttime = m_nLeftOffset / GetPixelsPerSecond();
+
+	float clicktime = (float)endx / GetPixelsPerSecond() + starttime;
+
+	float percent = clicktime / m_pWaveFile->GetRunningLength();
+	percent = clamp( percent, 0.0f, 1.0f );
+	
+	tag->SetPercentage( percent );
+
+	redraw();
+
+	if ( g_pChoreoView )
+	{
+		g_pChoreoView->InvalidateLayout();
+	}
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+// Input  : my - 
+// Output : Returns true on success, false on failure.
+//-----------------------------------------------------------------------------
+bool PhonemeEditor::IsMouseOverTagRow( int my )
+{
+	if ( GetMode() != MODE_PHONEMES )
+		return false;
+
+	if ( my < TAG_TOP || my > TAG_BOTTOM )
+		return false;
+
+	return true;
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+// Input  : mx - 
+//			my - 
+//-----------------------------------------------------------------------------
+void PhonemeEditor::ShowTagMenu( int mx, int my )
+{
+	if ( GetMode() != MODE_PHONEMES )
+		return;
+
+	// Figure out tag positions
+	if ( !m_pEvent || !m_pWaveFile )
+		return;
+
+	if ( !IsMouseOverTagRow( my ) )
+		return;
+
+	CEventRelativeTag *tag = GetTagUnderMouse( mx );
+
+	mxPopupMenu *pop = new mxPopupMenu();
+
+	if ( tag )
+	{
+		pop->add( va( "Delete tag '%s'", tag->GetName() ), IDC_DELETETAG );
+	}
+	else
+	{
+		pop->add( va( "Add tag..." ), IDC_ADDTAG );
+	}
+
+	m_nClickX = mx;
+
+	pop->popup( this, mx, my );
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+void PhonemeEditor::DeleteTag( void )
+{
+	if ( GetMode() != MODE_PHONEMES )
+		return;
+
+	// Figure out tag positions
+	if ( !m_pEvent )
+		return;
+
+	CEventRelativeTag *tag = GetTagUnderMouse( m_nClickX );
+	if ( !tag )
+		return;
+
+	// Remove it
+	m_pEvent->RemoveRelativeTag( tag->GetName() );
+
+	g_pChoreoView->InvalidateLayout();
+	redraw();
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+void PhonemeEditor::AddTag( void )
+{
+	if ( GetMode() != MODE_PHONEMES )
+		return;
+
+	// Figure out tag positions
+	if ( !m_pEvent || !m_pWaveFile )
+		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;
+	}
+
+	// Convert mouse position to time
+	float starttime = m_nLeftOffset / GetPixelsPerSecond();
+	float clicktime = (float)m_nClickX / GetPixelsPerSecond() + starttime;
+
+	float percent = clicktime / m_pWaveFile->GetRunningLength();
+	percent = min( 1.0f, percent );
+	percent = max( 0.0f, percent );
+
+	m_pEvent->AddRelativeTag( params.m_szInputText, percent );
+
+	g_pChoreoView->InvalidateLayout();
+
+	SetFocus( (HWND)getHandle() );
+
+	redraw();
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+void PhonemeEditor::ClearEvent( void )
+{
+	m_pEvent = NULL;
+	redraw();
+}
+
+void PhonemeEditor::TraverseWords( PEWORDITERFUNC pfn, float fparam )
+{
+	for ( int i = 0; i < m_Tags.m_Words.Size(); i++ )
+	{
+		CWordTag *word = m_Tags.m_Words[ i ];
+		if ( !word )
+			continue;
+
+		(this->*pfn)( word, fparam );
+	}
+}
+
+void PhonemeEditor::TraversePhonemes( PEPHONEMEITERFUNC pfn, float fparam )
+{
+	for ( int i = 0; i < m_Tags.m_Words.Size(); i++ )
+	{
+		CWordTag *word = m_Tags.m_Words[ i ];
+		if ( !word )
+			continue;
+
+		for ( int j = 0; j < word->m_Phonemes.Size(); j++ )
+		{
+			CPhonemeTag *phoneme = word->m_Phonemes[ j ];
+			if ( !phoneme )
+				continue;
+
+			(this->*pfn)( phoneme, word, fparam );
+		}
+	}
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+// Input  : amount - 
+//-----------------------------------------------------------------------------
+void PhonemeEditor::ITER_MoveSelectedWords( CWordTag *word, float amount )
+{
+	if ( !word->m_bSelected )
+		return;
+
+	word->m_flStartTime += amount;
+	word->m_flEndTime += amount;
+}
+
+void PhonemeEditor::ITER_MoveSelectedPhonemes( CPhonemeTag *phoneme, CWordTag *word, float amount )
+{
+	if ( !phoneme->m_bSelected )
+		return;
+
+	phoneme->AddStartTime( amount );
+	phoneme->AddEndTime( amount );
+
+}
+
+void PhonemeEditor::ITER_ExtendSelectedPhonemeEndTimes( CPhonemeTag *phoneme, CWordTag *word, float amount )
+{
+	if ( !phoneme->m_bSelected )
+		return;
+
+	if ( phoneme->GetEndTime() + amount <= phoneme->GetStartTime() )
+		return;
+
+	phoneme->AddEndTime( amount );
+
+	// Fixme, check for extending into next phoneme
+}
+
+
+void PhonemeEditor::ITER_ExtendSelectedWordEndTimes( CWordTag *word, float amount )
+{
+	if ( !word->m_bSelected )
+		return;
+
+	if ( word->m_flEndTime + amount <= word->m_flStartTime )
+		return;
+
+	word->m_flEndTime += amount;
+
+	// Fixme, check for extending into next word
+}
+
+void PhonemeEditor::ITER_AddFocusRectSelectedWords( CWordTag *word, float amount )
+{
+	if ( !word->m_bSelected )
+		return;
+
+	RECT wordRect;
+	GetWordRect( word, wordRect );
+
+	AddFocusRect( wordRect );
+}
+
+void PhonemeEditor::ITER_AddFocusRectSelectedPhonemes( CPhonemeTag *phoneme, CWordTag *word, float amount )
+{
+	if ( !phoneme->m_bSelected )
+		return;
+
+	RECT phonemeRect;
+	GetPhonemeRect( phoneme, phonemeRect );
+
+	AddFocusRect( phonemeRect );
+}
+
+
+void PhonemeEditor::AddFocusRect( RECT& rc )
+{
+	RECT rcFocus = rc;
+
+	POINT offset;
+	offset.x = 0;
+	offset.y = 0;
+	ClientToScreen( (HWND)getHandle(), &offset );
+	OffsetRect( &rcFocus, offset.x, offset.y );
+
+	// Convert to screen space?
+	CFocusRect fr;
+	fr.m_rcFocus = rcFocus;
+	fr.m_rcOrig = rcFocus;
+
+	m_FocusRects.AddToTail( fr );
+}
+
+void PhonemeEditor::CountSelected( void )
+{
+	m_nSelectedPhonemeCount = 0;
+	m_nSelectedWordCount = 0;
+
+	TraverseWords( &PhonemeEditor::ITER_CountSelectedWords, 0.0f );
+	TraversePhonemes( &PhonemeEditor::ITER_CountSelectedPhonemes, 0.0f );
+}
+
+void PhonemeEditor::ITER_CountSelectedWords( CWordTag *word, float amount )
+{
+	if ( !word->m_bSelected )
+		return;
+
+	m_nSelectedWordCount++;
+
+}
+
+void PhonemeEditor::ITER_CountSelectedPhonemes( CPhonemeTag *phoneme, CWordTag *word, float amount )
+{
+	if ( !phoneme->m_bSelected )
+		return;
+
+	m_nSelectedPhonemeCount++;
+}
+
+// Undo/Redo
+void PhonemeEditor::Undo( void )
+{
+	if ( m_UndoStack.Size() > 0 && m_nUndoLevel > 0 )
+	{
+		m_nUndoLevel--;
+		PEUndo *u = m_UndoStack[ m_nUndoLevel ];
+		Assert( u->undo );
+		m_Tags = *(u->undo);
+
+		SetClickedPhoneme( -1, -1 );
+	}
+
+	redraw();
+}
+
+void PhonemeEditor::Redo( void )
+{
+	if ( m_UndoStack.Size() > 0 && m_nUndoLevel <= m_UndoStack.Size() - 1 )
+	{
+		PEUndo *u = m_UndoStack[ m_nUndoLevel ];
+		Assert( u->redo );
+		m_Tags = *(u->redo);
+		m_nUndoLevel++;
+
+		SetClickedPhoneme( -1, -1 );
+	}
+
+	redraw();
+}
+
+void PhonemeEditor::PushUndo( void )
+{
+	Assert( !m_bRedoPending );
+	m_bRedoPending = true;
+	WipeRedo();
+
+	// Copy current data
+	CSentence *u = new CSentence();
+	*u = m_Tags;
+	PEUndo *undo = new PEUndo;
+	undo->undo = u;
+	undo->redo = NULL;
+	m_UndoStack.AddToTail( undo );
+	m_nUndoLevel++;
+}
+
+void PhonemeEditor::PushRedo( void )
+{
+	Assert( m_bRedoPending );
+	m_bRedoPending = false;
+
+	// Copy current data
+	CSentence *r = new CSentence();
+	*r = m_Tags;
+	PEUndo *undo = m_UndoStack[ m_nUndoLevel - 1 ];
+	undo->redo = r;
+}
+
+void PhonemeEditor::WipeUndo( void )
+{
+	while ( m_UndoStack.Size() > 0 )
+	{
+		PEUndo *u = m_UndoStack[ 0 ];
+		delete u->undo;
+		delete u->redo;
+		delete u;
+		m_UndoStack.Remove( 0 );
+	}
+	m_nUndoLevel = 0;
+}
+
+void PhonemeEditor::WipeRedo( void )
+{
+	// Wipe everything above level
+	while ( m_UndoStack.Size() > m_nUndoLevel )
+	{
+		PEUndo *u = m_UndoStack[ m_nUndoLevel ];
+		delete u->undo;
+		delete u->redo;
+		delete u;
+		m_UndoStack.Remove( m_nUndoLevel );
+	}
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+// Input  : word - 
+//			phoneme - 
+//-----------------------------------------------------------------------------
+void PhonemeEditor::SetClickedPhoneme( int word, int phoneme )
+{
+	m_nClickedPhoneme = phoneme;
+	m_nClickedWord = word;
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+// Output : CPhonemeTag
+//-----------------------------------------------------------------------------
+CPhonemeTag *PhonemeEditor::GetClickedPhoneme( void )
+{
+	if ( m_nClickedPhoneme < 0 || m_nClickedWord < 0 )
+		return NULL;
+
+	if ( m_nClickedWord >= m_Tags.m_Words.Size() )
+		return NULL;
+
+	CWordTag *word = m_Tags.m_Words[ m_nClickedWord ];
+	if ( !word )
+		return NULL;
+
+	if ( m_nClickedPhoneme >= word->m_Phonemes.Size() )
+		return NULL;
+
+	CPhonemeTag *phoneme = word->m_Phonemes[ m_nClickedPhoneme ];
+	return phoneme;
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+// Output : CWordTag
+//-----------------------------------------------------------------------------
+CWordTag *PhonemeEditor::GetClickedWord( void )
+{
+	if ( m_nClickedWord < 0 )
+		return NULL;
+
+	if ( m_nClickedWord >= m_Tags.m_Words.Size() )
+		return NULL;
+
+	CWordTag *word = m_Tags.m_Words[ m_nClickedWord ];
+	return word;
+}
+
+void PhonemeEditor::ShowContextMenu_Phonemes( int mx, int my )
+{
+	CountSelected();
+
+	// Construct main
+	mxPopupMenu *pop = new mxPopupMenu();
+
+	if ( m_pWaveFile )
+	{
+		mxPopupMenu *play = new mxPopupMenu;
+		play->add( va( "Original" ), IDC_PHONEME_PLAY_ORIG );
+		play->add( va( "Edited" ), IDC_PLAY_EDITED );
+		if ( m_bSelectionActive )
+		{
+			play->add( va( "Selection" ), IDC_PLAY_EDITED_SELECTION );
+		}
+
+		pop->addMenu( "Play", play );
+
+		if ( sound->IsSoundPlaying( m_pMixer ) )
+		{
+			pop->add( va( "Cancel playback" ), IDC_CANCELPLAYBACK );
+		}
+
+		pop->addSeparator();
+	}
+
+	pop->add( va( "Load..." ), IDC_LOADWAVEFILE );
+
+	if ( m_pWaveFile )
+	{
+		pop->add( va( "Save" ), IDC_SAVE_LINGUISTIC );
+	}
+
+	if ( m_bSelectionActive )
+	{
+		pop->addSeparator();
+		pop->add( va( "Deselect" ), IDC_DESELECT );
+	}
+
+	if ( m_pWaveFile )
+	{
+		pop->addSeparator();
+		pop->add( va( "Redo Extraction" ), IDC_REDO_PHONEMEEXTRACTION );
+
+		if ( m_nSelectedWordCount < 1 || AreSelectedWordsContiguous() )
+		{
+			pop->add( va( "Redo Extraction of selected words" ), IDC_REDO_PHONEMEEXTRACTION_SELECTION );
+		}
+	}
+
+	if ( m_pWaveFile && m_TagsExt.m_Words.Size() )
+	{
+		pop->addSeparator();
+		pop->add( va( "Commit extraction" ) , IDC_COMMITEXTRACTED );
+		pop->add( va( "Clear extraction" ), IDC_CLEAREXTRACTED );
+	}
+
+	if ( m_nUndoLevel != 0 || m_nUndoLevel != m_UndoStack.Size()  )
+	{
+		pop->addSeparator();
+		if ( m_nUndoLevel != 0 )
+		{
+			pop->add( va( "Undo" ), IDC_UNDO );
+		}
+		if ( m_nUndoLevel != m_UndoStack.Size() )
+		{
+			pop->add( va( "Redo" ), IDC_REDO );
+		}
+		pop->add( va( "Clear Undo Info" ), IDC_CLEARUNDO );
+	}
+
+	if ( m_Tags.m_Words.Size() > 0 )
+	{
+		pop->addSeparator();
+		pop->add( va( "Cleanup words/phonemes" ), IDC_CLEANUP );
+	}
+
+	// Show hierarchical options menu
+	{
+		mxPopupMenu *api = 0;
+		
+		if ( DoesExtractorExistFor( SPEECH_API_SAPI ) )
+		{
+			api = new mxPopupMenu();
+			api->add( "Microsoft Speech API", IDC_API_SAPI );
+			if ( g_viewerSettings.speechapiindex == SPEECH_API_SAPI )
+			{
+				api->setChecked( IDC_API_SAPI, true );
+			}
+		}
+
+		if ( DoesExtractorExistFor( SPEECH_API_LIPSINC ) )
+		{
+			if ( !api )
+				api = new mxPopupMenu();
+
+			api->add( "Lipsinc Speech API", IDC_API_LIPSINC );
+			if ( g_viewerSettings.speechapiindex == SPEECH_API_LIPSINC )
+			{
+				api->setChecked( IDC_API_LIPSINC, true );
+			}
+		}
+
+		pop->addSeparator();
+		pop->addMenu( "Change Speech API", api );
+	}
+
+	// Import export menu
+	if ( m_pWaveFile )
+	{
+		pop->addSeparator();
+		if ( m_Tags.m_Words.Count() > 0 )
+		{
+			pop->add( "Export word data to " WORD_DATA_EXTENSION "...", IDC_EXPORT_SENTENCE );
+		}
+		pop->add( "Import word data from " WORD_DATA_EXTENSION "...", IDC_IMPORT_SENTENCE );
+		pop->add( va("%s Voice Duck", m_Tags.GetVoiceDuck() ? "Disable" : "Enable" ), IDC_TOGGLE_VOICEDUCK );
+	}
+
+	pop->popup( this, mx, my );
+}
+
+void PhonemeEditor::ShowContextMenu_Emphasis( int mx, int my )
+{
+	Emphasis_CountSelected();
+
+	// Construct main
+	mxPopupMenu *pop = new mxPopupMenu();
+
+	pop->add( va( "Select All" ), IDC_EMPHASIS_SELECTALL );
+	if ( m_nNumSelected > 0 )
+	{
+		pop->add( va( "Deselect All" ), IDC_EMPHASIS_DESELECT );
+	}
+
+	if ( m_nUndoLevel != 0 || m_nUndoLevel != m_UndoStack.Size()  )
+	{
+		pop->addSeparator();
+
+		if ( m_nUndoLevel != 0 )
+		{
+			pop->add( va( "Undo" ), IDC_UNDO );
+		}
+		if ( m_nUndoLevel != m_UndoStack.Size() )
+		{
+			pop->add( va( "Redo" ), IDC_REDO );
+		}
+		pop->add( va( "Clear Undo Info" ), IDC_CLEARUNDO );
+	}
+	pop->popup( this, mx, my );
+}
+
+void PhonemeEditor::ShowContextMenu( int mx, int my )
+{
+	switch ( GetMode() )
+	{
+	default:
+	case MODE_PHONEMES:
+		ShowContextMenu_Phonemes( mx, my );
+		break;
+	case MODE_EMPHASIS:
+		ShowContextMenu_Emphasis( mx, my );
+		break;
+	}
+}
+
+void PhonemeEditor::ShiftSelectedPhoneme( int direction )
+{
+	if ( GetMode() != MODE_PHONEMES )
+		return;
+
+	CountSelected();
+
+	switch ( m_nSelectedPhonemeCount )
+	{
+	case 1:
+		break;
+	case 0:
+		Con_Printf( "Can't shift phonemes, none selected\n" );
+		return;
+	default:
+		Con_Printf( "Can only shift one phoneme at a time via keyboard\n" );
+		return;
+	}
+
+	RECT rc;
+	GetWorkspaceRect( rc );
+
+	// Determine start/stop positions
+	float starttime = m_nLeftOffset / GetPixelsPerSecond();
+	float endtime = w2() / GetPixelsPerSecond() + starttime;
+
+	float timeperpixel = ( endtime - starttime ) / (float)( rc.right - rc.left );
+
+	float movetime = timeperpixel * (float)direction;
+	
+	float maxmove = ComputeMaxPhonemeShift( direction > 0 ? true : false, false );
+
+	if ( direction > 0 )
+	{
+		if ( movetime > maxmove )
+		{
+			movetime = maxmove;
+			Con_Printf( "Further shift is blocked on right\n" );
+		}
+	}
+	else
+	{
+		if ( movetime < -maxmove )
+		{
+			movetime = -maxmove;
+			Con_Printf( "Further shift is blocked on left\n" );
+		}
+	}
+
+	if ( fabs( movetime ) < 0.0001f )
+		return;
+
+	SetDirty( true );
+
+	PushUndo();
+
+	TraversePhonemes( &PhonemeEditor::ITER_MoveSelectedPhonemes, movetime );
+
+	PushRedo();
+
+	m_bWordsActive = false;
+
+	redraw();
+
+	Con_Printf( "Shift phoneme %s\n", direction == -1 ? "left" : "right" );
+}
+
+void PhonemeEditor::ExtendSelectedPhonemeEndTime( int direction )
+{
+	if ( GetMode() != MODE_PHONEMES )
+		return;
+
+	CountSelected();
+
+	if ( m_nSelectedPhonemeCount != 1 )
+		return;
+
+	RECT rc;
+	GetWorkspaceRect( rc );
+
+	// Determine start/stop positions
+	float starttime = m_nLeftOffset / GetPixelsPerSecond();
+	float endtime = w2() / GetPixelsPerSecond() + starttime;
+
+	float timeperpixel = ( endtime - starttime ) / (float)( rc.right - rc.left );
+
+	float movetime = timeperpixel * (float)direction;
+
+	SetDirty( true );
+
+	PushUndo();
+
+	TraversePhonemes( &PhonemeEditor::ITER_ExtendSelectedPhonemeEndTimes, movetime );
+
+	PushRedo();
+
+	m_bWordsActive = false;
+
+	redraw();
+
+	Con_Printf( "Extend phoneme end %s\n", direction == -1 ? "left" : "right" );
+}
+
+void PhonemeEditor::SelectNextPhoneme( int direction )
+{
+	if ( GetMode() != MODE_PHONEMES )
+		return;
+
+	CountSelected();
+
+	if ( m_nSelectedPhonemeCount != 1 )
+	{
+		if ( m_nSelectedWordCount == 1 )
+		{
+			CWordTag *word = GetSelectedWord();
+			if ( word && word->m_Phonemes.Size() > 0 )
+			{
+				m_nSelectedPhonemeCount = 1;
+				CPhonemeTag *p = word->m_Phonemes[ direction ? word->m_Phonemes.Size() - 1 : 0 ];
+				p->m_bSelected = true;
+			}
+			else
+			{
+				return;
+			}
+		}
+		else
+		{
+			return;
+		}
+	}
+
+	Con_Printf( "Move to next phoneme %s\n", direction == -1 ? "left" : "right" );
+
+	for ( int i = 0; i < m_Tags.m_Words.Size(); i++ )
+	{
+		CWordTag *word = m_Tags.m_Words[ i ];
+		if ( !word )
+			continue;
+
+		for ( int j = 0; j < word->m_Phonemes.Size(); j++ )
+		{
+			CPhonemeTag *phoneme = word->m_Phonemes[ j ];
+			if ( !phoneme )
+				continue;
+
+			if ( !phoneme->m_bSelected )
+				continue;
+
+			// Deselect this one and move 
+			int nextindex = j + direction;
+			if ( nextindex < 0 )
+			{
+				nextindex = word->m_Phonemes.Size() - 1;
+			}
+			else if ( nextindex >= word->m_Phonemes.Size() )
+			{
+				nextindex = 0;
+			}
+
+			phoneme->m_bSelected = false;
+
+			phoneme = word->m_Phonemes[ nextindex ];
+
+			phoneme->m_bSelected = true;
+
+			m_bWordsActive = false;
+
+			redraw();
+			return;
+		}
+	}
+}
+
+bool PhonemeEditor::IsPhonemeSelected( CWordTag *word )
+{
+	for ( int i = 0 ; i < word->m_Phonemes.Size(); i++ )
+	{
+		CPhonemeTag *p = word->m_Phonemes[ i ];
+		if ( !p || !p->m_bSelected )
+			continue;
+
+		return true;
+	}
+	return false;
+}
+
+void PhonemeEditor::SelectNextWord( int direction )
+{
+	if ( GetMode() != MODE_PHONEMES )
+		return;
+
+	CountSelected();
+
+	if ( m_nSelectedWordCount != 1 &&
+		 m_nSelectedPhonemeCount != 1 )
+	{
+		// Selected first word then
+		if ( m_nSelectedWordCount == 0 && m_Tags.m_Words.Size() > 0 )
+		{
+			CWordTag *word = m_Tags.m_Words[ direction ? m_Tags.m_Words.Size() - 1 : 0 ];
+			word->m_bSelected = true;
+			m_nSelectedWordCount = 1;
+		}
+		else
+		{
+			return;
+		}
+	}
+
+	Con_Printf( "Move to next word %s\n", direction == -1 ? "left" : "right" );
+
+	for ( int i = 0; i < m_Tags.m_Words.Size(); i++ )
+	{
+		CWordTag *word = m_Tags.m_Words[ i ];
+		if ( !word )
+			continue;
+
+		if ( m_nSelectedWordCount == 1 )
+		{
+			if ( !word->m_bSelected )
+				continue;
+		}
+		else 
+		{
+			if ( !IsPhonemeSelected( word ) )
+				continue;
+		}
+
+		// Deselect word
+		word->m_bSelected = false;
+
+		for ( int j = 0; j < word->m_Phonemes.Size(); j++ )
+		{
+			CPhonemeTag *phoneme = word->m_Phonemes[ j ];
+			if ( !phoneme )
+				continue;
+
+			if ( !phoneme->m_bSelected )
+				continue;
+
+			phoneme->m_bSelected = false;
+		}
+
+		// Deselect this one and move 
+		int nextword = i + direction;
+		if ( nextword < 0 )
+		{
+			nextword = m_Tags.m_Words.Size() - 1;
+		}
+		else if ( nextword >= m_Tags.m_Words.Size() )
+		{
+			nextword = 0;
+		}
+
+		word = m_Tags.m_Words[ nextword ];
+		word->m_bSelected = true;
+
+		if ( word->m_Phonemes.Size() > 0 )
+		{
+			CPhonemeTag *phoneme = NULL;
+
+			if ( direction > 0 )
+			{
+				phoneme = word->m_Phonemes[ 0 ];
+			}
+			else
+			{
+				phoneme = word->m_Phonemes[ word->m_Phonemes.Size() - 1 ];
+			}
+
+			phoneme->m_bSelected = true;
+		}
+
+		m_bWordsActive = true;
+
+		redraw();
+		return;
+	}
+}
+
+void PhonemeEditor::ShiftSelectedWord( int direction )
+{
+	if ( GetMode() != MODE_PHONEMES )
+		return;
+
+	CountSelected();
+
+	switch ( m_nSelectedWordCount )
+	{
+	case 1:
+		break;
+	case 0:
+		Con_Printf( "Can't shift words, none selected\n" );
+		return;
+	default:
+		Con_Printf( "Can only shift one word at a time via keyboard\n" );
+		return;
+	}
+
+	RECT rc;
+	GetWorkspaceRect( rc );
+
+	// Determine start/stop positions
+	float starttime = m_nLeftOffset / GetPixelsPerSecond();
+	float endtime = w2() / GetPixelsPerSecond() + starttime;
+
+	float timeperpixel = ( endtime - starttime ) / (float)( rc.right - rc.left );
+
+	float movetime = timeperpixel * (float)direction;
+
+	float maxmove = ComputeMaxWordShift( direction > 0 ? true : false, false );
+
+	if ( direction > 0 )
+	{
+		if ( movetime > maxmove )
+		{
+			movetime = maxmove;
+			Con_Printf( "Further shift is blocked on right\n" );
+		}
+	}
+	else
+	{
+		if ( movetime < -maxmove )
+		{
+			movetime = -maxmove;
+			Con_Printf( "Further shift is blocked on left\n" );
+		}
+	}
+
+	if ( fabs( movetime ) < 0.0001f )
+		return;
+
+	SetDirty( true );
+
+	PushUndo();
+
+	TraverseWords( &PhonemeEditor::ITER_MoveSelectedWords, movetime );
+
+	PushRedo();
+
+	m_bWordsActive = true;
+
+	redraw();
+
+	Con_Printf( "Shift word %s\n", direction == -1 ? "left" : "right" );
+}
+
+void PhonemeEditor::ExtendSelectedWordEndTime( int direction )
+{
+	if ( GetMode() != MODE_PHONEMES )
+		return;
+
+	CountSelected();
+
+	if ( m_nSelectedWordCount != 1 )
+		return;
+
+	RECT rc;
+	GetWorkspaceRect( rc );
+
+	// Determine start/stop positions
+	float starttime = m_nLeftOffset / GetPixelsPerSecond();
+	float endtime = w2() / GetPixelsPerSecond() + starttime;
+
+	float timeperpixel = ( endtime - starttime ) / (float)( rc.right - rc.left );
+
+	float movetime = timeperpixel * (float)direction;
+
+	SetDirty( true );
+
+	PushUndo();
+
+	TraverseWords( &PhonemeEditor::ITER_ExtendSelectedWordEndTimes, movetime );
+
+	PushRedo();
+
+	m_bWordsActive = true;
+
+	redraw();
+
+	Con_Printf( "Extend word end %s\n", direction == -1 ? "left" : "right" );
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+// Input  : *word - 
+// Output : int
+//-----------------------------------------------------------------------------
+int PhonemeEditor::IndexOfWord( CWordTag *word )
+{
+	for ( int i = 0 ; i < m_Tags.m_Words.Size(); i++ )
+	{
+		if ( m_Tags.m_Words[ i ] == word )
+			return i;
+	}
+	return -1;
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+// Input  : forward - 
+//			*currentWord - 
+//			**nextWord - 
+// Output : float
+//-----------------------------------------------------------------------------
+float PhonemeEditor::GetTimeGapToNextWord( bool forward, CWordTag *currentWord, CWordTag **ppNextWord /* = NULL */ )
+{
+	if ( ppNextWord )
+	{
+		*ppNextWord = NULL;
+	}
+
+	if ( !currentWord )
+		return 0.0f;
+
+	int wordnum = IndexOfWord( currentWord );
+	if ( wordnum == -1 )
+		return 0.0f;
+
+	// Go in correct direction
+	int newwordnum = wordnum + ( forward ? 1 : -1 );
+
+	// There is no next word
+	if ( newwordnum >= m_Tags.m_Words.Size() )
+	{
+		return PLENTY_OF_TIME;
+	}
+
+	// There is no previous word
+	if ( newwordnum < 0 )
+	{
+		return PLENTY_OF_TIME;
+	}
+
+	if ( ppNextWord )
+	{
+		*ppNextWord = m_Tags.m_Words[ newwordnum ];
+	}
+
+	// Otherwise, figure out time gap
+	if ( forward )
+	{
+		float currentEnd = currentWord->m_flEndTime;
+		float nextStart = m_Tags.m_Words[ newwordnum ]->m_flStartTime;
+
+		return ( nextStart - currentEnd );
+	}
+	else
+	{
+		float previousEnd = m_Tags.m_Words[ newwordnum ]->m_flEndTime;
+		float currentStart = currentWord->m_flStartTime;
+
+		return ( currentStart - previousEnd );
+	}
+
+	
+	Assert( 0 );
+	return 0.0f;
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+// Input  : forward - 
+//			*currentPhoneme - 
+//			**word - 
+//			**phoneme - 
+// Output : float
+//-----------------------------------------------------------------------------
+float PhonemeEditor::GetTimeGapToNextPhoneme( bool forward, CPhonemeTag *currentPhoneme, 
+	CWordTag **ppword /* = NULL */, CPhonemeTag **ppphoneme /* = NULL */ )
+{
+	if ( ppword )
+	{
+		*ppword = NULL;
+	}
+	if ( ppphoneme )
+	{
+		*ppphoneme = NULL;
+	}
+
+	if ( !currentPhoneme )
+		return 0.0f;
+
+	CWordTag *word = m_Tags.GetWordForPhoneme( currentPhoneme );
+	if ( !word )
+		return 0.0f;
+
+	int wordnum = IndexOfWord( word );
+	Assert( wordnum != -1 );
+
+	int phonemenum = word->IndexOfPhoneme( currentPhoneme );
+	if ( phonemenum < 0  )
+		return 0.0f;
+
+	CPhonemeTag *nextPhoneme = NULL;
+
+	int nextphoneme = phonemenum + ( forward ? 1 : -1 );
+
+	// Try last phoneme of previous word
+	if ( nextphoneme < 0 )
+	{
+		wordnum--;
+		while ( wordnum >= 0 )
+		{
+			if ( ppword )
+			{
+				*ppword = m_Tags.m_Words[ wordnum ];
+			}
+			if ( m_Tags.m_Words.Size() > 0 )
+			{
+				if ( m_Tags.m_Words[ wordnum ]->m_Phonemes.Size() > 0 )
+				{
+					nextPhoneme = m_Tags.m_Words[ wordnum ]->m_Phonemes[ m_Tags.m_Words[ wordnum ]->m_Phonemes.Size() - 1 ];
+					break;
+				}
+			}
+			wordnum--;
+		}
+	}
+	// Try first phoneme of next word, if there is one
+	else if ( nextphoneme >= word->m_Phonemes.Size() )
+	{
+		wordnum++;
+		while ( wordnum < m_Tags.m_Words.Size() )
+		{
+			if ( ppword )
+			{
+				*ppword = m_Tags.m_Words[ wordnum ];
+			}
+			// Really it can't be zero, but check anyway
+			if ( m_Tags.m_Words.Size() > 0 )
+			{
+				if ( m_Tags.m_Words[ wordnum ]->m_Phonemes.Size() > 0 )
+				{
+					nextPhoneme = m_Tags.m_Words[ wordnum ]->m_Phonemes[ 0 ];
+					break;
+				}
+			}
+			wordnum++;
+		}
+	}
+	else
+	{
+		nextPhoneme = word->m_Phonemes[ nextphoneme ];
+	}
+
+	if ( !nextPhoneme )
+		return PLENTY_OF_TIME;
+
+	if ( ppphoneme )
+	{
+		*ppphoneme = nextPhoneme;
+	}
+
+	// Now compute time delta
+	float dt = 0.0f;
+	if ( forward )
+	{
+		dt = nextPhoneme->GetStartTime() - currentPhoneme->GetEndTime();
+	}
+	else
+	{
+		dt = currentPhoneme->GetStartTime() - nextPhoneme->GetEndTime();
+	}
+
+	return dt;
+}
+
+CPhonemeTag *PhonemeEditor::GetSelectedPhoneme( void )
+{
+	CountSelected();
+
+	if ( m_nSelectedPhonemeCount != 1 )
+		return NULL;
+
+	for ( int i = 0; i < m_Tags.m_Words.Size(); i++ )
+	{
+		CWordTag *w = m_Tags.m_Words[ i ];
+		if ( !w )
+			continue;
+
+		for ( int j = 0; j < w->m_Phonemes.Size() ; j++ )
+		{
+			CPhonemeTag *p = w->m_Phonemes[ j ];
+			if ( !p || !p->m_bSelected )
+				continue;
+
+			return p;
+		}
+	}
+	return NULL;
+}
+
+CWordTag *PhonemeEditor::GetSelectedWord( void )
+{
+	CountSelected();
+
+	if ( m_nSelectedWordCount != 1 )
+		return NULL;
+
+	for ( int i = 0; i < m_Tags.m_Words.Size(); i++ )
+	{
+		CWordTag *w = m_Tags.m_Words[ i ];
+		if ( !w || !w->m_bSelected )
+			continue;
+
+		return w;
+	}
+	return NULL;
+}
+
+void PhonemeEditor::OnMouseMove( mxEvent *event )
+{
+	int mx = (short)event->x;
+
+	LimitDrag( mx );
+
+	event->x = (short)mx;
+
+	if ( m_nDragType != DRAGTYPE_NONE )
+	{
+		DrawFocusRect( "moving old" );
+
+		for ( int i = 0; i < m_FocusRects.Size(); i++ )
+		{
+			CFocusRect *f = &m_FocusRects[ i ];
+			f->m_rcFocus = f->m_rcOrig;
+
+			switch ( m_nDragType )
+			{
+			default:
+				{
+					// Only X Shifts supported
+					OffsetRect( &f->m_rcFocus, ( (short)event->x - m_nStartX ),
+						0 );
+				}
+				break;
+			case DRAGTYPE_EMPHASIS_SELECT:
+				{
+					RECT rcWork;
+					GetWorkspaceRect( rcWork );
+					RECT rcEmphasis;
+					Emphasis_GetRect( rcWork, rcEmphasis );
+
+					RECT rcFocus;
+
+					rcFocus = f->m_rcOrig;
+
+					rcFocus.left = m_nStartX < (short)event->x ? m_nStartX : (short)event->x;
+					rcFocus.right = m_nStartX < (short)event->x ? (short)event->x : m_nStartX;
+					
+					rcFocus.top = m_nStartY < (short)event->y ? m_nStartY : (short)event->y;
+					rcFocus.bottom = m_nStartY < (short)event->y ? (short)event->y : m_nStartY;
+
+					rcFocus.top = clamp( rcFocus.top, rcEmphasis.top, rcEmphasis.bottom );
+					rcFocus.bottom = clamp( rcFocus.bottom, rcEmphasis.top, rcEmphasis.bottom );
+
+					//OffsetRect( &rcFocus, 0, -rcEmphasis.top );
+
+					POINT offset;
+					offset.x = 0;
+					offset.y = 0;
+					ClientToScreen( (HWND)getHandle(), &offset );
+					OffsetRect( &rcFocus, offset.x, offset.y );
+
+					f->m_rcFocus = rcFocus;
+				}
+				break;
+			}
+		}
+
+		if ( m_nDragType == DRAGTYPE_EMPHASIS_MOVE )
+		{
+			redraw();
+		}
+
+		DrawFocusRect( "moving new" );
+	}
+	else
+	{
+		if ( m_hPrevCursor )
+		{
+			SetCursor( m_hPrevCursor );
+			m_hPrevCursor = NULL;
+		}
+
+		CountSelected();
+
+		int overhandle = IsMouseOverBoundary( event );
+		if ( overhandle == BOUNDARY_PHONEME && m_nSelectedPhonemeCount <= 1 )
+		{
+			m_hPrevCursor = SetCursor( LoadCursor( NULL, IDC_SIZEWE ) );
+		}
+		else if ( overhandle == BOUNDARY_WORD && m_nSelectedWordCount <= 1 )
+		{
+			m_hPrevCursor = SetCursor( LoadCursor( NULL, IDC_SIZEWE ) );
+		}
+		else if ( IsMouseOverSelection( (short)event->x, (short)event->y ) )
+		{
+			if ( IsMouseOverSelectionStartEdge( event ) )
+			{
+				m_hPrevCursor = SetCursor( LoadCursor( NULL, IDC_SIZEWE ) );
+			}
+			else if ( IsMouseOverSelectionEndEdge( event ) )
+			{
+				m_hPrevCursor = SetCursor( LoadCursor( NULL, IDC_SIZEWE ) );
+			}
+			else
+			{
+				if ( event->modifiers & mxEvent::KeyShift )
+				{
+					m_hPrevCursor = SetCursor( LoadCursor( NULL, IDC_SIZEALL ) );
+				}
+			}
+		}
+		else
+		{
+			if ( IsMouseOverTag( (short)event->x, (short)event->y ) )
+			{
+				m_hPrevCursor = SetCursor( LoadCursor( NULL, IDC_SIZEALL ) );
+			}
+			else
+			{
+				CPhonemeTag *pt = GetPhonemeTagUnderMouse( (short)event->x, (short)event->y );
+				CWordTag *wt = GetWordTagUnderMouse( (short)event->x, (short)event->y );
+				if ( wt || pt )
+				{
+					if ( pt )
+					{
+						// Select it
+						SelectExpression( pt );
+					}
+					if ( event->modifiers & mxEvent::KeyShift )
+					{
+						m_hPrevCursor = SetCursor( LoadCursor( NULL, IDC_SIZEALL ) );
+					}
+				}
+			}
+		}
+	}
+
+	switch ( m_nDragType )
+	{
+	default:
+		break;
+	case DRAGTYPE_EMPHASIS_MOVE:
+		{
+			Emphasis_MouseDrag( (short)event->x, (short)event->y );
+			m_Tags.Resort();
+		}
+		break;
+	case DRAGTYPE_SCRUBBER:
+		{
+			float t = GetTimeForPixel( (short)event->x );
+			t += m_flScrubberTimeOffset;
+
+			ClampTimeToSelectionInterval( t );
+
+			float dt = t - m_flScrub;
+
+			SetScrubTargetTime( t );
+
+			ScrubThink( dt, true );
+
+			SetScrubTime( t );
+
+			DrawScrubHandle();
+		}
+		break;
+	}
+
+	m_nLastX = (short)event->x;
+	m_nLastY = (short)event->y;
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+void PhonemeEditor::EditInsertFirstPhonemeOfWord( void )
+{
+	if ( GetMode() != MODE_PHONEMES )
+		return;
+
+	CWordTag *cw = GetSelectedWord();
+	if ( !cw )
+		return;
+
+	if ( cw->m_Phonemes.Size() != 0 )
+	{
+		Con_Printf( "Can't insert first phoneme into %s, already has phonemes\n", cw->GetWord() );
+		return;
+	}
+
+	CPhonemeParams params;
+	memset( &params, 0, sizeof( params ) );
+	strcpy( params.m_szDialogTitle, "Phoneme/Viseme Properties" );
+	strcpy( params.m_szName, "" );
+
+	params.m_nLeft = -1;
+	params.m_nTop = -1;
+
+	params.m_bPositionDialog = true;
+	params.m_bMultiplePhoneme = true;
+
+	if ( params.m_bPositionDialog )
+	{
+		RECT rcWord;
+		GetWordRect( cw, rcWord );
+
+		// Convert to screen coords
+		POINT pt;
+		pt.x = rcWord.left;
+		pt.y = rcWord.top;
+
+		ClientToScreen( (HWND)getHandle(), &pt );
+
+		params.m_nLeft	= pt.x;
+		params.m_nTop	= pt.y;
+	}
+
+	int iret = PhonemeProperties( &params );
+	SetFocus( (HWND)getHandle() );
+	if ( !iret )
+	{
+		return;
+	}
+
+	int phonemeCount = CSentence::CountWords( params.m_szName );
+	if ( phonemeCount <= 0 )
+	{
+		return;
+	}
+
+	float wordLength = cw->m_flEndTime - cw->m_flStartTime;
+	float timePerPhoneme = wordLength / (float)phonemeCount;
+
+	float currentTime = cw->m_flStartTime;
+
+	SetDirty( true );
+
+	PushUndo();
+
+	unsigned char *in;
+	char *out;
+
+	char phonemeName[ 128 ];
+
+	in = (unsigned char *)params.m_szName;
+
+	do
+	{
+		out = phonemeName;
+
+		while ( *in > 32 )
+		{
+			*out++ = *in++;
+		}
+		*out = 0;
+
+		CPhonemeTag phoneme;
+
+		phoneme.SetPhonemeCode( TextToPhoneme( phonemeName ) );
+		phoneme.SetTag( phonemeName );
+
+		phoneme.SetStartTime( currentTime );
+		phoneme.SetEndTime( currentTime + timePerPhoneme );
+		phoneme.m_bSelected = false;
+
+		cw->m_Phonemes.AddToTail( new CPhonemeTag( phoneme ) );
+
+		currentTime += timePerPhoneme;
+
+		if ( !*in )
+			break;
+
+		// Skip whitespace
+		in++;
+
+	} while ( 1 );
+
+	cw->m_Phonemes[ 0 ]->m_bSelected = true;
+
+	PushRedo();
+
+	// Add it
+	redraw();
+}
+
+void PhonemeEditor::SelectPhonemes( bool forward )
+{
+	if ( GetMode() != MODE_PHONEMES )
+		return;
+
+	CountSelected();
+
+	if ( m_nSelectedPhonemeCount != 1 )
+		return;
+
+	CPhonemeTag *phoneme = GetSelectedPhoneme();
+	if ( !phoneme )
+		return;
+
+	// Figure out it's word and index
+	CWordTag *word = m_Tags.GetWordForPhoneme( phoneme );
+	if ( !word )
+		return;
+
+	int wordNum = IndexOfWord( word );
+	if ( wordNum == -1 )
+		return;
+
+	// Select remaining phonemes in current word
+	int i;
+
+	i = word->IndexOfPhoneme( phoneme );
+	if ( i == -1 )
+		return;
+
+	if ( forward )
+	{
+		// Start at next one
+		i++;
+
+		for ( ; i < word->m_Phonemes.Size(); i++ )
+		{
+			phoneme = word->m_Phonemes[ i ];
+			phoneme->m_bSelected = true;
+		}
+
+		// Now start at next word
+		wordNum++;
+
+		for ( ; wordNum < m_Tags.m_Words.Size(); wordNum++ )
+		{
+			word = m_Tags.m_Words[ wordNum ];
+
+			for ( int j = 0; j < word->m_Phonemes.Size(); j++ )
+			{
+				phoneme = word->m_Phonemes[ j ];
+				phoneme->m_bSelected = true;
+			}
+		}
+	}
+	else
+	{
+		// Start at previous
+		i--;
+
+		for ( ; i >= 0; i-- )
+		{
+			phoneme = word->m_Phonemes[ i ];
+			phoneme->m_bSelected = true;
+		}
+
+		// Now start at previous word
+		wordNum--;
+
+		for ( ; wordNum >= 0 ; wordNum-- )
+		{
+			word = m_Tags.m_Words[ wordNum ];
+
+			for ( int j = 0; j < word->m_Phonemes.Size(); j++ )
+			{
+				phoneme = word->m_Phonemes[ j ];
+				phoneme->m_bSelected = true;
+			}
+		}
+	}
+
+	redraw();
+}
+
+void PhonemeEditor::SelectWords( bool forward )
+{
+	if ( GetMode() != MODE_PHONEMES )
+		return;
+
+	CountSelected();
+
+	if ( m_nSelectedWordCount != 1 )
+		return;
+
+	// Figure out it's word and index
+	CWordTag *word = GetSelectedWord();
+	if ( !word )
+		return;
+
+	int wordNum = IndexOfWord( word );
+	if ( wordNum == -1 )
+		return;
+
+	if ( forward )
+	{
+		wordNum++;
+
+		for ( ; wordNum < m_Tags.m_Words.Size(); wordNum++ )
+		{
+			word = m_Tags.m_Words[ wordNum ];
+			word->m_bSelected = true;
+		}
+	}
+	else
+	{
+		wordNum--;
+
+		for ( ; wordNum >= 0; wordNum-- )
+		{
+			word = m_Tags.m_Words[ wordNum ];
+			word->m_bSelected = true;
+		}
+
+	}
+
+	redraw();
+}
+
+bool PhonemeEditor::AreSelectedWordsContiguous( void )
+{
+	CountSelected();
+
+	if ( m_nSelectedWordCount < 1 )
+		return false;
+
+	if ( m_nSelectedWordCount == 1 )
+		return true;
+
+	// Find first selected word
+	int runcount = 0;
+	bool parity = false;
+
+	for ( int i = 0 ; i < m_Tags.m_Words.Size() ; i++ )
+	{
+		CWordTag *word = m_Tags.m_Words[ i ];
+		if ( !word )
+			continue;
+
+		if ( word->m_bSelected )
+		{
+			if ( !parity )
+			{
+				parity = true;
+				runcount++;
+			}
+		}
+		else
+		{
+			if ( parity )
+			{
+				parity = false;
+			}
+		}
+	}
+
+	if ( runcount == 1 )
+		return true;
+
+	return false;
+}
+
+bool PhonemeEditor::AreSelectedPhonemesContiguous( void )
+{
+	CountSelected();
+
+	if ( m_nSelectedPhonemeCount < 1 )
+		return false;
+
+	if ( m_nSelectedPhonemeCount == 1 )
+		return true;
+
+	// Find first selected word
+	int runcount = 0;
+	bool parity = false;
+
+	for ( int i = 0 ; i < m_Tags.m_Words.Size() ; i++ )
+	{
+		CWordTag *word = m_Tags.m_Words[ i ];
+		if ( !word )
+			continue;
+
+		for ( int j = 0 ; j < word->m_Phonemes.Size(); j++ )
+		{
+			CPhonemeTag *phoneme = word->m_Phonemes[ j ];
+			if ( !phoneme )
+				continue;
+
+			if ( phoneme->m_bSelected )
+			{
+				if ( !parity )
+				{
+					parity = true;
+					runcount++;
+				}
+			}
+			else
+			{
+				if ( parity )
+				{
+					parity = false;
+				}
+			}
+		}
+	}
+
+	if ( runcount == 1 )
+		return true;
+
+	return false;
+
+}
+
+void PhonemeEditor::SortWords( bool prepareundo )
+{
+	if ( prepareundo )
+	{
+		SetDirty( true );
+		PushUndo();
+	}
+
+	// Just bubble sort by start time
+	int c = m_Tags.m_Words.Count();
+
+	int i;
+
+	// check for start > end
+	for ( i = 0; i < c; i++ )
+	{
+		CWordTag *p1 = m_Tags.m_Words[ i ];
+		if (p1->m_flStartTime > p1->m_flEndTime )
+		{
+			float swap = p1->m_flStartTime;			
+			p1->m_flStartTime = p1->m_flEndTime;
+			p1->m_flEndTime = swap;
+		}
+	}
+
+	for ( i = 0; i < c; i++ )
+	{
+		for ( int j = i + 1; j < c; j++ )
+		{
+			CWordTag *p1 = m_Tags.m_Words[ i ];
+			CWordTag *p2 = m_Tags.m_Words[ j ];
+
+			if ( p1->m_flStartTime < p2->m_flStartTime )
+				continue;
+
+			// Swap them
+			m_Tags.m_Words[ i ] = p2;
+			m_Tags.m_Words[ j ] = p1;
+		}
+	}
+
+	if ( prepareundo )
+	{
+		PushRedo();
+	}
+}
+
+void PhonemeEditor::SortPhonemes( bool prepareundo )
+{
+	if ( prepareundo )
+	{
+		SetDirty( true );
+		PushUndo();
+	}
+
+	// Just bubble sort by start time
+	int wc = m_Tags.m_Words.Count();
+	for ( int w = 0; w < wc; w++ )
+	{
+		CWordTag *word = m_Tags.m_Words[ w ];
+		Assert( word );
+
+		int c = word->m_Phonemes.Count();
+		int i;
+
+		// check for start > end
+		for ( i = 0; i < c; i++ )
+		{
+			CPhonemeTag *p1 = word->m_Phonemes[ i ];
+
+			if (p1->GetStartTime() > p1->GetEndTime() )
+			{
+				float swap = p1->GetStartTime();			
+				p1->SetStartTime( p1->GetEndTime() );
+				p1->SetEndTime( swap );
+			}
+		}
+
+		for ( i = 0; i < c; i++ )
+		{
+			for ( int j = i + 1; j < c; j++ )
+			{
+				CPhonemeTag *p1 = word->m_Phonemes[ i ];
+				CPhonemeTag *p2 = word->m_Phonemes[ j ];
+
+				if ( p1->GetStartTime() < p2->GetStartTime() )
+					continue;
+
+				// Swap them
+				word->m_Phonemes[ i ] = p2;
+				word->m_Phonemes[ j ] = p1;
+			}
+		}
+	}
+
+	if ( prepareundo )
+	{
+		PushRedo();
+	}
+}
+
+void PhonemeEditor::CleanupWordsAndPhonemes( bool prepareundo )
+{
+	if ( GetMode() != MODE_PHONEMES )
+		return;
+
+	// 2 pixel gap
+	float snap_epsilon = 2.49f / GetPixelsPerSecond();
+
+	if ( prepareundo )
+	{
+		SetDirty( true );
+		PushUndo();
+	}
+
+	SortWords( false );
+	SortPhonemes( false );
+
+	for ( int i = 0 ; i < m_Tags.m_Words.Size() ; i++ )
+	{
+		CWordTag *word = m_Tags.m_Words[ i ];
+		if ( !word )
+			continue;
+
+		CWordTag *next = NULL;
+		if ( i < m_Tags.m_Words.Size() - 1 )
+		{
+			next = m_Tags.m_Words[ i + 1 ];
+		}
+
+		if ( word && next )
+		{
+			// Check for words close enough
+			float eps = next->m_flStartTime - word->m_flEndTime;
+			if ( eps && eps <= snap_epsilon )
+			{
+				float t = (word->m_flEndTime + next->m_flStartTime) * 0.5;
+				word->m_flEndTime = t;
+				next->m_flStartTime = t;
+			}
+		}
+
+		for ( int j = 0 ; j < word->m_Phonemes.Size(); j++ )
+		{
+			CPhonemeTag *phoneme = word->m_Phonemes[ j ];
+			if ( !phoneme )
+				continue;
+
+			CPhonemeTag *next = NULL;
+			if ( j < word->m_Phonemes.Size() - 1 )
+			{
+				next = word->m_Phonemes[ j + 1 ];
+			}
+
+			if ( phoneme && next )
+			{
+				float eps = next->GetStartTime() - phoneme->GetEndTime();
+				if ( eps && eps <= snap_epsilon )
+				{
+					float t = (phoneme->GetEndTime() + next->GetStartTime() ) * 0.5;
+					phoneme->SetEndTime( t );
+					next->SetStartTime( t );
+				}
+			}
+		}
+	}
+
+	if ( prepareundo )
+	{
+		PushRedo();
+	}
+
+	// NOTE: Caller must call "redraw()" to get screen to update
+}
+
+
+
+void PhonemeEditor::RealignPhonemesToWords( bool prepareundo )
+{
+	if ( GetMode() != MODE_PHONEMES )
+		return;
+
+	if ( prepareundo )
+	{
+		SetDirty( true );
+		PushUndo();
+	}
+
+	SortWords( false );
+	SortPhonemes( false );
+
+	for ( int i = 0 ; i < m_Tags.m_Words.Size() ; i++ )
+	{
+		CWordTag *word = m_Tags.m_Words[ i ];
+		if ( !word )
+			continue;
+
+		CWordTag *next = NULL;
+		if ( i < m_Tags.m_Words.Size() - 1 )
+		{
+			next = m_Tags.m_Words[ i + 1 ];
+		}
+
+		float word_dt = word->m_flEndTime - word->m_flStartTime;
+
+		CPhonemeTag *FirstPhoneme = word->m_Phonemes[ 0 ];
+		if ( !FirstPhoneme )
+			continue;
+
+		CPhonemeTag *LastPhoneme = word->m_Phonemes[ word->m_Phonemes.Size() - 1 ];
+		if ( !LastPhoneme )
+			continue;
+
+		float phoneme_dt = LastPhoneme->GetEndTime() - FirstPhoneme->GetStartTime();
+
+		float phoneme_shift = FirstPhoneme->GetStartTime();
+
+		for ( int j = 0 ; j < word->m_Phonemes.Size(); j++ )
+		{
+			CPhonemeTag *phoneme = word->m_Phonemes[ j ];
+			if ( !phoneme )
+				continue;
+
+			CPhonemeTag *next = NULL;
+			if ( j < word->m_Phonemes.Size() - 1 )
+			{
+				next = word->m_Phonemes[ j + 1 ];
+			}
+
+			if (j == 0)
+			{
+				float t = (phoneme->GetStartTime() - phoneme_shift ) * (word_dt / phoneme_dt) + word->m_flStartTime;
+				phoneme->SetStartTime( t );
+			}
+
+			float t = (phoneme->GetEndTime() - phoneme_shift ) * (word_dt / phoneme_dt) + word->m_flStartTime;
+			phoneme->SetEndTime( t );
+			if (next)
+			{
+				next->SetStartTime( t );
+			}
+		}
+	}
+
+	if ( prepareundo )
+	{
+		PushRedo();
+	}
+
+	// NOTE: Caller must call "redraw()" to get screen to update
+}
+
+
+void PhonemeEditor::RealignWordsToPhonemes( bool prepareundo )
+{
+	if ( GetMode() != MODE_PHONEMES )
+		return;
+
+	if ( prepareundo )
+	{
+		SetDirty( true );
+		PushUndo();
+	}
+
+	SortWords( false );
+	SortPhonemes( false );
+
+	for ( int i = 0 ; i < m_Tags.m_Words.Size() ; i++ )
+	{
+		CWordTag *word = m_Tags.m_Words[ i ];
+		if ( !word )
+			continue;
+
+		CPhonemeTag *FirstPhoneme = word->m_Phonemes[ 0 ];
+		if ( !FirstPhoneme )
+			continue;
+
+		CPhonemeTag *LastPhoneme = word->m_Phonemes[ word->m_Phonemes.Size() - 1 ];
+		if ( !LastPhoneme )
+			continue;
+
+		word->m_flStartTime = FirstPhoneme->GetStartTime();
+		word->m_flEndTime = LastPhoneme->GetEndTime();
+	}
+
+	if ( prepareundo )
+	{
+		PushRedo();
+	}
+
+	// NOTE: Caller must call "redraw()" to get screen to update
+}
+
+
+
+float PhonemeEditor::ComputeMaxWordShift( bool forward, bool allowcrop )
+{
+	// skipping selected words, figure out max time shift of words before they selection touches any
+	// unselected words
+	// if allowcrop is true, then the maximum extends up to end of next word
+	float maxshift = PLENTY_OF_TIME;
+
+	if ( forward )
+	{
+		for ( int i = 0; i < m_Tags.m_Words.Size(); i++ )
+		{
+			CWordTag *w1 = m_Tags.m_Words[ i ];
+			if ( !w1 || !w1->m_bSelected )
+				continue;
+
+			CWordTag *w2 = NULL;
+			for ( int search = i + 1; search < m_Tags.m_Words.Size() ; search++ )
+			{
+				CWordTag *check = m_Tags.m_Words[ search ];
+				if ( !check || check->m_bSelected )
+					continue;
+
+				w2 = check;
+				break;
+			}
+
+			if ( w2 )
+			{
+				float shift;
+				if ( allowcrop )
+				{
+					shift = w2->m_flEndTime - w1->m_flEndTime;
+				}
+				else
+				{
+					shift = w2->m_flStartTime - w1->m_flEndTime;
+				}
+
+				if ( shift < maxshift )
+				{
+					maxshift = shift;
+				}
+			}
+		}
+	}
+	else
+	{
+		for ( int i = m_Tags.m_Words.Size() -1; i >= 0; i-- )
+		{
+			CWordTag *w1 = m_Tags.m_Words[ i ];
+			if ( !w1 || !w1->m_bSelected )
+				continue;
+
+			CWordTag *w2 = NULL;
+			for ( int search = i - 1; search >= 0 ; search-- )
+			{
+				CWordTag *check = m_Tags.m_Words[ search ];
+				if ( !check || check->m_bSelected )
+					continue;
+
+				w2 = check;
+				break;
+			}
+
+			if ( w2 )
+			{
+				float shift;
+				if ( allowcrop )
+				{
+					shift = w1->m_flStartTime - w2->m_flStartTime;
+				}
+				else
+				{
+					shift = w1->m_flStartTime - w2->m_flEndTime;
+				}
+
+				if ( shift < maxshift )
+				{
+					maxshift = shift;
+				}
+			}
+		}
+	}
+
+	return maxshift;
+}
+
+float PhonemeEditor::ComputeMaxPhonemeShift( bool forward, bool allowcrop )
+{
+	// skipping selected phonemes, figure out max time shift of phonemes before they selection touches any
+	// unselected words
+	// if allowcrop is true, then the maximum extends up to end of next word
+	float maxshift = PLENTY_OF_TIME;
+
+	if ( forward )
+	{
+		for ( int i = 0; i < m_Tags.m_Words.Size(); i++ )
+		{
+			CWordTag *word = m_Tags.m_Words[ i ];
+			if ( !word )
+				continue;
+
+			for ( int j = 0; j < word->m_Phonemes.Size(); j++ )
+			{
+				CPhonemeTag *p1 = word->m_Phonemes[ j ];
+				if ( !p1 || !p1->m_bSelected )
+					continue;
+
+				// Find next unselected phoneme
+				CPhonemeTag *p2 = NULL;
+
+				CPhonemeTag *start = p1;
+				do
+				{
+					CPhonemeTag *test = NULL;
+					GetTimeGapToNextPhoneme( forward, start, NULL, &test );
+					if ( !test )
+						break;
+
+					if ( test->m_bSelected )
+					{
+						start = test;
+						continue;
+					}
+
+					p2 = test;
+					break;
+				} while ( 1 );
+
+				if ( p2 )
+				{
+					float shift;
+					if ( allowcrop )
+					{
+						shift = p2->GetEndTime() - p1->GetEndTime();
+					}
+					else
+					{
+						shift = p2->GetStartTime() - p1->GetEndTime();
+					}
+
+					if ( shift < maxshift )
+					{
+						maxshift = shift;
+					}
+				}
+			}
+		}
+	}
+	else
+	{
+		for ( int i = m_Tags.m_Words.Size() -1; i >= 0; i-- )
+		{
+			CWordTag *word = m_Tags.m_Words[ i ];
+			if ( !word )
+				continue;
+
+			for ( int j = word->m_Phonemes.Size() - 1; j >= 0; j-- )
+			{
+				CPhonemeTag *p1 = word->m_Phonemes[ j ];
+				if ( !p1 || !p1->m_bSelected )
+					continue;
+
+				// Find previous unselected phoneme
+				CPhonemeTag *p2 = NULL;
+
+				CPhonemeTag *start = p1;
+				do
+				{
+					CPhonemeTag *test = NULL;
+					GetTimeGapToNextPhoneme( forward, start, NULL, &test );
+					if ( !test )
+						break;
+
+					if ( test->m_bSelected )
+					{
+						start = test;
+						continue;
+					}
+
+					p2 = test;
+					break;
+				} while ( 1 );
+
+				if ( p2 )
+				{
+					float shift;
+					if ( allowcrop )
+					{
+						shift = p1->GetStartTime() - p2->GetStartTime();
+					}
+					else
+					{
+						shift = p1->GetStartTime() - p2->GetEndTime();
+					}
+
+					if ( shift < maxshift )
+					{
+						maxshift = shift;
+					}
+				}
+			}
+		}
+	}
+
+	return maxshift;
+}
+
+int PhonemeEditor::PixelsForDeltaTime( float dt )
+{
+	if ( !dt )
+		return 0;
+
+	RECT rc;
+	GetWorkspaceRect( rc );
+
+	float starttime = m_nLeftOffset / GetPixelsPerSecond();
+	float endtime = w2() / GetPixelsPerSecond() + starttime;
+
+	float timeperpixel = ( endtime - starttime ) / (float)( rc.right - rc.left );
+
+	float pixels = dt / timeperpixel;
+
+	return abs( (int)pixels );
+}
+
+void PhonemeEditor::ClearDragLimit( void )
+{
+	m_bLimitDrag = false;
+	m_nLeftLimit = -1;
+	m_nRightLimit = -1;
+}
+
+void PhonemeEditor::SetDragLimit( int dragtype )
+{
+	ClearDragLimit();
+
+	float nextW, nextP;
+	float prevW, prevP;
+
+	nextW = ComputeMaxWordShift( true, false );
+	prevW = ComputeMaxWordShift( false, false );
+	nextP = ComputeMaxPhonemeShift( true, false );
+	prevP = ComputeMaxPhonemeShift( false, false );
+
+	/*
+	Con_Printf( "+w %f -w %f +p %f -p %f\n",
+		1000.0f * nextW,
+		1000.0f * prevW,
+		1000.0f * nextP,
+		1000.0f * prevP );
+	*/
+
+	switch ( dragtype )
+	{
+	case DRAGTYPE_MOVEWORD:
+		m_bLimitDrag = true;
+		m_nLeftLimit = PixelsForDeltaTime( prevW );
+		m_nRightLimit = PixelsForDeltaTime( nextW );
+		break;
+	case DRAGTYPE_MOVEPHONEME:
+		m_bLimitDrag = true;
+		m_nLeftLimit = PixelsForDeltaTime( prevP );
+		m_nRightLimit = PixelsForDeltaTime( nextP );
+		break;
+	default:
+		ClearDragLimit();
+		break;
+	}
+}
+
+void PhonemeEditor::LimitDrag( int& mousex )
+{
+	if ( m_nDragType == DRAGTYPE_NONE )
+		return;
+
+	if ( !m_bLimitDrag )
+		return;
+
+	int delta = mousex - m_nStartX;
+	if ( delta > 0 )
+	{
+		if ( m_nRightLimit >= 0 )
+		{
+			if ( delta > m_nRightLimit )
+			{
+				mousex = m_nStartX + m_nRightLimit;
+			}
+		}
+	}
+	else if ( delta < 0 )
+	{
+		if ( m_nLeftLimit >= 0 )
+		{
+			if ( abs( delta ) > abs( m_nLeftLimit ) )
+			{
+				mousex = m_nStartX - m_nLeftLimit;
+			}
+		}
+	}
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: Wipe undo/redo data
+//-----------------------------------------------------------------------------
+void PhonemeEditor::ClearUndo( void )
+{
+	WipeUndo();
+	WipeRedo();
+
+	SetDirty( false );
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+// Input  : *tag - 
+//-----------------------------------------------------------------------------
+void PhonemeEditor::SelectExpression( CPhonemeTag *tag )
+{
+	if ( !models->GetActiveStudioModel() )
+		return;
+
+	CStudioHdr *hdr = models->GetActiveStudioModel()->GetStudioHdr();
+	if ( !hdr )
+		return;
+
+	// Make sure phonemes are loaded
+	FacePoser_EnsurePhonemesLoaded();
+
+	CExpClass *cl = expressions->FindClass( "phonemes", true );
+	if ( !cl )
+	{
+		Con_Printf( "Couldn't load expressions/phonemes.txt!\n" );
+		return;
+	}
+
+	if ( expressions->GetActiveClass() != cl )
+	{
+		expressions->ActivateExpressionClass( cl );
+	}
+
+	CExpression *exp = cl->FindExpression( ConvertPhoneme( tag->GetPhonemeCode() ) );
+	if ( !exp )
+	{
+		Con_Printf( "Couldn't find phoneme '%s'\n", ConvertPhoneme( tag->GetPhonemeCode() )  );
+		return;
+	}
+
+	float *settings = exp->GetSettings();
+	for (LocalFlexController_t i = LocalFlexController_t(0); i < hdr->numflexcontrollers(); i++)
+	{
+		int j = hdr->pFlexcontroller( i )->localToGlobal;
+
+		models->GetActiveStudioModel()->SetFlexController( i, settings[j] );
+	}
+}
+
+void PhonemeEditor::OnSAPI( void )
+{
+	if ( GetMode() != MODE_PHONEMES )
+		return;
+
+	g_viewerSettings.speechapiindex = SPEECH_API_SAPI;
+
+	m_pPhonemeExtractor = NULL;
+
+	CheckSpeechAPI();
+
+	redraw();
+}
+
+void PhonemeEditor::OnLipSinc( void )
+{
+	if ( GetMode() != MODE_PHONEMES )
+		return;
+
+	g_viewerSettings.speechapiindex = SPEECH_API_LIPSINC;
+
+	m_pPhonemeExtractor = NULL;
+
+	CheckSpeechAPI();
+
+	redraw();
+}
+
+void PhonemeEditor::LoadPhonemeConverters()
+{
+	m_pPhonemeExtractor = NULL;
+
+	// Enumerate modules under bin folder of exe
+	FileFindHandle_t findHandle;
+	const char *pFilename = filesystem->FindFirstEx( "phonemeextractors/*.dll", "EXECUTABLE_PATH", &findHandle );
+	while( pFilename )
+	{	
+		char fullpath[ 512 ];
+		Q_snprintf( fullpath, sizeof( fullpath ), "phonemeextractors/%s", pFilename );
+
+		Con_Printf( "Loading extractor from %s\n", fullpath );
+
+		Extractor e;
+		e.module = Sys_LoadModule( fullpath );
+		if ( !e.module )
+		{
+			pFilename = filesystem->FindNext( findHandle );
+			continue;
+		}
+
+		CreateInterfaceFn factory = Sys_GetFactory( e.module );
+		if ( !factory )
+		{
+			pFilename = filesystem->FindNext( findHandle );
+			continue;
+		}
+
+		e.extractor = ( IPhonemeExtractor * )factory( VPHONEME_EXTRACTOR_INTERFACE, NULL );
+		if ( !e.extractor )
+		{
+			Warning( "Unable to get IPhonemeExtractor interface version %s from %s\n", VPHONEME_EXTRACTOR_INTERFACE, fullpath );
+			pFilename = filesystem->FindNext( findHandle );
+			continue;
+		}
+
+		e.apitype = e.extractor->GetAPIType();
+
+		g_Extractors.AddToTail( e );
+		pFilename = filesystem->FindNext( findHandle );
+	}
+
+	filesystem->FindClose( findHandle );
+}
+
+void PhonemeEditor::ValidateSpeechAPIIndex()
+{
+	if ( !DoesExtractorExistFor( (PE_APITYPE)g_viewerSettings.speechapiindex ) )
+	{
+		if ( g_Extractors.Count() > 0 )
+			g_viewerSettings.speechapiindex = g_Extractors[0].apitype;
+	}
+}
+
+void PhonemeEditor::UnloadPhonemeConverters()
+{
+	int c = g_Extractors.Count();
+	for ( int i = c - 1; i >= 0; i-- )
+	{
+		Extractor *e = &g_Extractors[ i ];
+		Sys_UnloadModule( e->module );
+	}
+
+	g_Extractors.RemoveAll();
+
+	m_pPhonemeExtractor = NULL;
+}
+
+bool PhonemeEditor::CheckSpeechAPI( void )
+{
+	if ( GetMode() != MODE_PHONEMES )
+	{
+		return false;
+	}
+
+	if ( !m_pPhonemeExtractor )
+	{
+		int c = g_Extractors.Count();
+		for ( int i = 0; i < c; i++ )
+		{
+			Extractor *e = &g_Extractors[ i ];
+			if ( e->apitype == (PE_APITYPE)g_viewerSettings.speechapiindex )
+			{
+				m_pPhonemeExtractor = e->extractor;
+				break;
+			}
+		}
+
+		if ( !m_pPhonemeExtractor )
+		{
+			Con_ErrorPrintf( "Couldn't find phoneme extractor %i\n",
+				g_viewerSettings.speechapiindex );
+		}
+	}
+
+	return m_pPhonemeExtractor != NULL;
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+// Output : char const
+//-----------------------------------------------------------------------------
+char const *PhonemeEditor::GetSpeechAPIName( void )
+{
+	CheckSpeechAPI();
+
+	if ( m_pPhonemeExtractor )
+	{
+		return m_pPhonemeExtractor->GetName();
+	}
+
+	return "Unknown Speech API";
+}
+
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+// Output : Returns true on success, false on failure.
+//-----------------------------------------------------------------------------
+bool PhonemeEditor::PaintBackground( void )
+{
+	redraw();
+	return false;
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+// Output : PhonemeEditor::EditorMode
+//-----------------------------------------------------------------------------
+PhonemeEditor::EditorMode PhonemeEditor::GetMode( void ) const
+{
+	return m_CurrentMode;
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+// Input  : rcWorkSpace - 
+//			rcEmphasis - 
+//-----------------------------------------------------------------------------
+void PhonemeEditor::Emphasis_GetRect( RECT const & rcWorkSpace, RECT& rcEmphasis )
+{
+	rcEmphasis = rcWorkSpace;
+
+	int ybottom = rcWorkSpace.bottom - 2 * m_nTickHeight - 2;
+	int workspaceheight = rcWorkSpace.bottom - rcWorkSpace.top;
+	
+	// Just past midpoint
+	rcEmphasis.top		= rcWorkSpace.top + workspaceheight / 2 + 2;
+	// 60 units or 
+	rcEmphasis.bottom = clamp( rcEmphasis.top + 60, rcEmphasis.top + 20, ybottom );
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+void PhonemeEditor::OnModeChanged( void )
+{
+	// Show/hide controls as necessary
+}
+
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+// Input  : *parent - 
+//-----------------------------------------------------------------------------
+void PhonemeEditor::Emphasis_Init( void )
+{
+	m_nNumSelected = 0;
+}
+
+CEmphasisSample *PhonemeEditor::Emphasis_GetSampleUnderMouse( mxEvent *event )
+{
+	if ( GetMode() != MODE_EMPHASIS )
+		return NULL;
+
+	if ( !m_pWaveFile )
+		return NULL;
+
+	if ( w2() <= 0 )
+		return NULL;
+
+	if ( GetPixelsPerSecond() <= 0 )
+		return NULL;
+
+	float timeperpixel = 1.0f / GetPixelsPerSecond();
+	float closest_dist = 999999.0f;
+	CEmphasisSample *bestsample = NULL;
+
+	int samples = m_Tags.GetNumSamples();
+
+	float clickTime = GetTimeForPixel( (short)event->x );
+
+	for ( int i = 0; i < samples; i++ )
+	{
+		CEmphasisSample *sample = m_Tags.GetSample( i );
+
+		float dist = fabs( sample->time - clickTime );
+		if ( dist < closest_dist )
+		{
+			bestsample = sample;
+			closest_dist = dist;
+		}
+
+	}
+
+	// Not close to any of them!!!
+	if ( closest_dist > ( 5.0f * timeperpixel ) )
+	{
+		return NULL;
+	}
+
+	return bestsample;
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+void PhonemeEditor::Emphasis_DeselectAll( void )
+{
+	if ( GetMode() != MODE_EMPHASIS )
+		return;
+
+	for ( int i = 0; i < m_Tags.GetNumSamples(); i++ )
+	{
+		CEmphasisSample *sample = m_Tags.GetSample( i );
+		sample->selected = false;
+	}
+	redraw();
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+void PhonemeEditor::Emphasis_SelectAll( void )
+{
+	if ( GetMode() != MODE_EMPHASIS )
+		return;
+
+	for ( int i = 0; i <  m_Tags.GetNumSamples(); i++ )
+	{
+		CEmphasisSample *sample = m_Tags.GetSample( i );
+		sample->selected = true;
+	}
+	redraw();
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+void PhonemeEditor::Emphasis_Delete( void )
+{
+	if ( GetMode() != MODE_EMPHASIS )
+		return;
+
+	SetDirty( true );
+
+	PushUndo();
+
+	for ( int i = m_Tags.GetNumSamples() - 1; i >= 0 ; i-- )
+	{
+		CEmphasisSample *sample = m_Tags.GetSample( i );
+		if ( !sample->selected )
+			continue;
+
+		m_Tags.m_EmphasisSamples.Remove( i );
+
+		SetDirty( true );
+	}
+
+	PushRedo();
+
+	redraw();
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+// Input  : sample - 
+//-----------------------------------------------------------------------------
+void PhonemeEditor::Emphasis_AddSample( CEmphasisSample const& sample )
+{
+	if ( GetMode() != MODE_EMPHASIS )
+		return;
+
+	SetDirty( true );
+
+	PushUndo();
+
+	m_Tags.m_EmphasisSamples.AddToTail( sample );
+	m_Tags.Resort();
+
+	PushRedo();
+
+	redraw();
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+void PhonemeEditor::Emphasis_CountSelected( void )
+{
+	m_nNumSelected = 0;
+
+	for ( int i = 0; i < m_Tags.GetNumSamples(); i++ )
+	{
+		CEmphasisSample *sample = m_Tags.GetSample( i );
+		if ( !sample || !sample->selected )
+			continue;
+
+		m_nNumSelected++;
+	}
+}
+
+void PhonemeEditor::Emphasis_ShowContextMenu( mxEvent *event )
+{
+	if ( GetMode() != MODE_EMPHASIS )
+		return;
+
+	CountSelected();
+
+	// Construct main menu
+	mxPopupMenu *pop = new mxPopupMenu();
+
+	if ( m_nNumSelected > 0 )
+	{
+		pop->add( va( "Delete" ), IDC_EMPHASIS_DELETE );
+		pop->add( "Deselect all", IDC_EMPHASIS_DESELECT );
+	}
+	pop->add( "Select all", IDC_EMPHASIS_SELECTALL );
+
+	pop->popup( this, (short)event->x, (short)event->y );
+}
+
+void PhonemeEditor::Emphasis_MouseDrag( int x, int y )
+{
+	if ( m_nDragType != DRAGTYPE_EMPHASIS_MOVE )
+		return;
+
+	RECT rcWork;
+	GetWorkspaceRect( rcWork );
+
+	RECT rc;
+	Emphasis_GetRect( rcWork, rc );
+
+	int height = rc.bottom - rc.top;
+
+	int dx = x - m_nLastX;
+	int dy = y - m_nLastY;
+
+	float dfdx = (float)dx * GetTimePerPixel();
+	float dfdy = (float)dy / (float)height;
+
+	for ( int i = 0; i < m_Tags.GetNumSamples(); i++ )
+	{
+		CEmphasisSample *sample = m_Tags.GetSample( i );
+		if ( !sample || !sample->selected )
+			continue;
+
+		sample->time += dfdx;
+		//sample->time = clamp( sample->time, 0.0f, 1.0f );
+
+		sample->value -= dfdy;
+		sample->value = clamp( sample->value, 0.0f, 1.0f );
+	}
+}
+
+void PhonemeEditor::Emphasis_Redraw( CChoreoWidgetDrawHelper& drawHelper, RECT& rcWorkSpace )
+{
+	if ( GetMode() != MODE_EMPHASIS &&
+		 GetMode() != MODE_PHONEMES )
+		return;
+
+	bool fullmode = GetMode() == MODE_EMPHASIS;
+	RECT rcClient;
+
+	Emphasis_GetRect( rcWorkSpace, rcClient );
+
+	RECT rcText;
+	rcText = rcClient;
+
+	InflateRect( &rcText, -15, 0 );
+
+	OffsetRect( &rcText, 0, -20 );
+	rcText.bottom = rcText.top + 20;
+
+	if ( fullmode )
+	{
+		drawHelper.DrawColoredText( "Arial", 15, FW_BOLD, PEColor( COLOR_PHONEME_EMPHASIS_TEXT ), rcText, "Emphasis..." );
+	}
+
+	{
+		int h = rcClient.bottom - rcClient.top;
+		int offset = h/3;
+		RECT rcSpot = rcClient;
+		rcSpot.bottom = rcSpot.top + offset;
+		
+		drawHelper.DrawGradientFilledRect( 
+			rcSpot, 
+			PEColor( COLOR_PHONEME_EMPHASIS_BG_STRONG ), 
+			PEColor( COLOR_PHONEME_EMPHASIS_BG ), 
+			true );
+
+		OffsetRect( &rcSpot, 0, offset );
+
+		drawHelper.DrawFilledRect( PEColor( COLOR_PHONEME_EMPHASIS_BG ), rcSpot );
+
+		OffsetRect( &rcSpot, 0, offset );
+
+		drawHelper.DrawGradientFilledRect( 
+			rcSpot, 
+			PEColor( COLOR_PHONEME_EMPHASIS_BG ), 
+			PEColor( COLOR_PHONEME_EMPHASIS_BG_WEAK ), 
+			true );
+	}
+
+	COLORREF gray = PEColor( COLOR_PHONEME_EMPHASIS_MIDLINE );
+
+	drawHelper.DrawOutlinedRect( PEColor( COLOR_PHONEME_EMPHASIS_BORDER ), PS_SOLID, 1, rcClient );
+
+	COLORREF lineColor = PEColor( COLOR_PHONEME_EMPHASIS_LINECOLOR );
+	COLORREF dotColor = PEColor( COLOR_PHONEME_EMPHASIS_DOTCOLOR );
+	COLORREF dotColorSelected = PEColor( COLOR_PHONEME_EMPHASIS_DOTCOLOR_SELECTED );
+
+	int midy = ( rcClient.bottom + rcClient.top ) / 2;
+
+	drawHelper.DrawColoredLine( gray, PS_SOLID, 1, rcClient.left, midy,
+		rcClient.right, midy );
+	int height = rcClient.bottom - rcClient.top;
+	int bottom = rcClient.bottom - 1;
+
+	if ( !m_pWaveFile )
+		return;
+
+	float running_length = m_pWaveFile->GetRunningLength();
+
+	// FIXME: adjust this based on framerate....
+	float timeperpixel = GetTimePerPixel();
+
+	float starttime, endtime;
+	GetScreenStartAndEndTime( starttime, endtime );
+
+	int prevx = 0;
+	float prev_t = starttime;
+	float prev_value = m_Tags.GetIntensity( prev_t, running_length );
+
+	int dx = 5;
+
+	for ( int x = 0; x < ( w2() + dx ); x += dx )
+	{
+		float t = GetTimeForPixel( x );
+
+		float value = m_Tags.GetIntensity( t, running_length );
+
+		// Draw segment
+		drawHelper.DrawColoredLine( lineColor, PS_SOLID, 1,
+			prevx, 
+			bottom - prev_value * height,
+			x, 
+			bottom - value * height );
+
+		prev_t = t;
+		prev_value = value;
+		prevx = x;
+
+	}
+
+	int numsamples = m_Tags.GetNumSamples();
+
+	for ( int sample = 0; sample < numsamples; sample++ )
+	{
+		CEmphasisSample *start = m_Tags.GetSample( sample );
+
+		int x = ( start->time - starttime ) / timeperpixel;
+
+		float value = m_Tags.GetIntensity( start->time, running_length );
+		int y = bottom - value * height;
+
+		int dotsize = 4;
+		int dotSizeSelected = 5;
+
+		COLORREF clr = dotColor;
+		COLORREF clrSelected = dotColorSelected;
+
+		drawHelper.DrawCircle( 
+			start->selected ? clrSelected : clr, 
+			x, y, 
+			start->selected ? dotSizeSelected : dotsize,
+			true );
+
+	}
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+// Output : Returns true on success, false on failure.
+//-----------------------------------------------------------------------------
+bool PhonemeEditor::Emphasis_IsValid( void )
+{
+	if ( m_Tags.GetNumSamples() > 0 )
+		return true;
+
+	return false;
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+void PhonemeEditor::Emphasis_SelectPoints( void )
+{
+	if ( GetMode() != MODE_EMPHASIS )
+		return;
+
+	RECT rcWork, rcEmphasis;
+	GetWorkspaceRect( rcWork );
+
+	Emphasis_GetRect( rcWork, rcEmphasis );
+
+	RECT rcSelection;
+	
+	rcSelection.left = m_nStartX < m_nLastX ? m_nStartX : m_nLastX;
+	rcSelection.right = m_nStartX < m_nLastX ? m_nLastX : m_nStartX;
+
+	rcSelection.top = m_nStartY < m_nLastY ? m_nStartY : m_nLastY;
+	rcSelection.bottom = m_nStartY < m_nLastY ? m_nLastY : m_nStartY;
+
+	rcSelection.top = max( rcSelection.top, rcEmphasis.top );
+	rcSelection.bottom = min( rcSelection.bottom, rcEmphasis.bottom );
+
+	int eh, ew;
+
+	eh = rcEmphasis.bottom - rcEmphasis.top;
+	ew = rcEmphasis.right - rcEmphasis.left;
+
+	InflateRect( &rcSelection, 5, 5 );
+
+	if ( !w2() || !h2() )
+		return;
+
+	float fleft = GetTimeForPixel( rcSelection.left );
+	float fright = GetTimeForPixel( rcSelection.right );
+
+	float ftop = (float)( rcSelection.top - rcEmphasis.top ) / (float)eh;
+	float fbottom = (float)( rcSelection.bottom- rcEmphasis.top ) / (float)eh;
+
+	//fleft = clamp( fleft, 0.0f, 1.0f );
+	//fright = clamp( fright, 0.0f, 1.0f );
+	ftop = clamp( ftop, 0.0f, 1.0f );
+	fbottom = clamp( fbottom, 0.0f, 1.0f );
+
+	float eps = 0.005;
+
+	for ( int i = 0; i < m_Tags.GetNumSamples(); i++ )
+	{
+		CEmphasisSample *sample = m_Tags.GetSample( i );
+		
+		if ( sample->time + eps < fleft )
+			continue;
+
+		if ( sample->time - eps > fright )
+			continue;
+
+		if ( (1.0f - sample->value ) + eps < ftop )
+			continue;
+
+		if ( (1.0f - sample->value ) - eps > fbottom )
+			continue;
+
+		sample->selected = true;
+	}
+
+	redraw();
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+// Input  : rcHandle - 
+//-----------------------------------------------------------------------------
+void PhonemeEditor::GetScrubHandleRect( RECT& rcHandle, bool clipped )
+{
+	float pixel = 0.0f;
+
+	if ( m_pWaveFile )
+	{
+		float currenttime = m_flScrub;
+		float starttime, endtime;
+		GetScreenStartAndEndTime( starttime, endtime );
+
+		float screenfrac = ( currenttime - starttime ) / ( endtime - starttime );
+
+		pixel = screenfrac * w2();
+
+		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() + 12;
+	rcHandle.bottom = rcHandle.top + SCRUBBER_HANDLE_HEIGHT;
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+// Input  : rcArea - 
+//-----------------------------------------------------------------------------
+void PhonemeEditor::GetScrubAreaRect( RECT& rcArea )
+{
+	rcArea.left = 0;
+	rcArea.right = w2();
+	rcArea.top = 2 + GetCaptionHeight() + 12;
+	rcArea.bottom = rcArea.top + SCRUBBER_HEIGHT - 4;
+}
+
+void PhonemeEditor::DrawScrubHandle()
+{
+	RECT rcHandle;
+	GetScrubHandleRect( rcHandle, true );
+	rcHandle.left = 0;
+	rcHandle.right = w2();
+
+	CChoreoWidgetDrawHelper drawHelper( this, rcHandle );
+
+	DrawScrubHandle( drawHelper );
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+// Input  : drawHelper - 
+//			rcHandle - 
+//-----------------------------------------------------------------------------
+void PhonemeEditor::DrawScrubHandle( CChoreoWidgetDrawHelper& drawHelper )
+{
+	RECT rcHandle;
+	GetScrubHandleRect( rcHandle, true );
+
+	HBRUSH br = CreateSolidBrush( RGB( 0, 150, 100 ) );
+
+	COLORREF areaBorder = RGB( 230, 230, 220 );
+
+	drawHelper.DrawColoredLine( areaBorder,
+		PS_SOLID, 1, 0, rcHandle.top, w2(), rcHandle.top );
+	drawHelper.DrawColoredLine( areaBorder,
+		PS_SOLID, 1, 0, rcHandle.bottom, w2(), rcHandle.bottom );
+
+	drawHelper.DrawFilledRect( br, rcHandle );
+
+	// 
+	char sz[ 32 ];
+	sprintf( sz, "%.3f", m_flScrub );
+
+	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 PhonemeEditor::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 PhonemeEditor::IsMouseOverScrubArea( mxEvent *event )
+{
+	RECT rcArea;
+
+	rcArea.left = 0;
+	rcArea.right = w2();
+	rcArea.top = 2 + GetCaptionHeight() + 12;
+	rcArea.bottom = rcArea.top + 10;
+
+	InflateRect( &rcArea, 2, 2 );
+
+	POINT pt;
+	pt.x = (short)event->x;
+	pt.y = (short)event->y;
+	if ( PtInRect( &rcArea, pt ) )
+	{
+		return true;
+	}
+
+	return false;
+}
+
+float PhonemeEditor::GetTimeForSample( int sample )
+{
+	if ( !m_pWaveFile )
+	{
+		return 0.0f;
+	}
+
+	float duration = m_pWaveFile->GetRunningLength();
+	int sampleCount = m_pWaveFile->SampleCount();
+	if ( sampleCount <= 0 )
+		return 0.0f;
+
+	float frac = (float)sample / (float)sampleCount;
+
+	return frac * duration;
+}
+
+void PhonemeEditor::ClampTimeToSelectionInterval( float& timeval )
+{
+	if ( !m_pWaveFile )
+	{
+		return;
+	}
+	if ( !m_pMixer || !sound->IsSoundPlaying( m_pMixer ) )
+	{
+		return;
+	}
+
+	if ( !m_bSelectionActive )
+		return;
+
+	float starttime = GetTimeForSample( m_nSelection[ 0 ] );
+	float endtime = GetTimeForSample( m_nSelection[ 1 ] );
+
+	Assert( starttime <= endtime );
+
+	timeval = clamp( timeval, starttime, endtime );
+}
+
+void PhonemeEditor::ScrubThink( float dt, bool scrubbing )
+{
+	ClampTimeToSelectionInterval( m_flScrub );
+	ClampTimeToSelectionInterval( m_flScrubTarget );
+
+	if ( m_flScrubTarget == m_flScrub && !scrubbing )
+	{
+		if ( sound->IsSoundPlaying( m_pMixer ) )
+		{
+			sound->StopSound( m_pMixer );
+		}
+		return;
+	}
+
+	if ( !m_pWaveFile )
+		return;
+
+	bool newmixer = false;
+	if ( !m_pMixer || !sound->IsSoundPlaying( m_pMixer ) )
+	{
+		m_pMixer = NULL;
+		SaveLinguisticData();
+
+		StudioModel *model = NULL;//models->GetActiveStudioModel();
+
+		sound->PlaySound( model, VOL_NORM, m_WorkFile.m_szWorkingFile, &m_pMixer );
+		newmixer = true;
+	}
+
+	if ( !m_pMixer )
+	{
+		return;
+	}
+
+	if ( m_flScrub > m_flScrubTarget )
+	{
+		m_pMixer->SetDirection( false );
+	}
+	else
+	{
+		m_pMixer->SetDirection( true );
+	}
+
+	float duration = m_pWaveFile->GetRunningLength();
+	if ( !duration )
+		return;
+
+	float d = m_flScrubTarget - m_flScrub;
+	int sign = d > 0.0f ? 1 : -1;
+
+	float maxmove = dt * m_flPlaybackRate;
+
+	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;
+		}
+	}
+
+	int sampleCount = m_pMixer->GetSource()->SampleCount();
+
+	int cursample = sampleCount * ( m_flScrub / duration );
+
+	int realsample = m_pMixer->GetSamplePosition();
+
+	int dsample = cursample - realsample;
+
+	int onehundredth = m_pMixer->GetSource()->SampleRate() * 0.01f;
+
+	if ( abs( dsample ) > onehundredth )
+	{
+		m_pMixer->SetSamplePosition( cursample, true );
+	}
+	m_pMixer->SetActive( true );
+
+	RECT rcArea;
+	GetScrubAreaRect( rcArea );
+
+	CChoreoWidgetDrawHelper drawHelper( this, rcArea );
+	DrawScrubHandle( drawHelper );
+
+	if ( scrubbing )
+	{
+		g_pMatSysWindow->Frame();
+	}
+}
+
+void PhonemeEditor::SetScrubTime( float t )
+{
+	m_flScrub = t;
+	ClampTimeToSelectionInterval( m_flScrub );
+}
+
+void PhonemeEditor::SetScrubTargetTime( float t )
+{
+	m_flScrubTarget = t;
+	ClampTimeToSelectionInterval( m_flScrubTarget );
+}
+
+
+void PhonemeEditor::OnToggleVoiceDuck()
+{
+	SetDirty( true );
+	PushUndo();
+	m_Tags.SetVoiceDuck( !m_Tags.GetVoiceDuck() );
+	PushRedo();
+	redraw();
+}
+
+void PhonemeEditor::Play()
+{
+	PlayEditedWave( m_bSelectionActive );
+}
+
+
+
+
+