gesturetool.cpp

hl2 source code. Do not use it illegal.

	if ( !event )
		return NULL;

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

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

	for ( int t = 0; t < CChoreoEvent::NUM_ABS_TAG_TYPES; t++ )
	{
		CChoreoEvent::AbsTagType tagtype = ( CChoreoEvent::AbsTagType )t;

		for ( int i = 0; i < event->GetNumAbsoluteTags( tagtype ); i++ )
		{
			CEventAbsoluteTag *tag = event->GetAbsoluteTag( tagtype, i );
			if ( !tag )
				continue;

			RECT rcTag;

			if ( !GetAbsTagRect( rcClient, event, tagtype, tag, rcTag ) )
				continue;

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

			return tag;
		}
	}

	return NULL;
}

//-----------------------------------------------------------------------------
// Purpose: 
// Input  : mx - 
//			my - 
// Output : int
//-----------------------------------------------------------------------------
int GestureTool::GetTagTypeForMouse( int mx, int my )
{
	RECT rcClient;
	rcClient.left = 0;
	rcClient.right = w2();
	rcClient.top = 0;
	rcClient.bottom = h2();

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

	for ( int t = 0; t < CChoreoEvent::NUM_ABS_TAG_TYPES; t++ )
	{
		RECT rcTray;
		GetTagTrayRect( rcClient, t, rcTray );

		if ( PtInRect( &rcTray, pt ) )
		{
			return t;
		}
	}
	return -1;
}

void GestureTool::OnInsertTag( void )
{
	CChoreoEvent *event = GetSafeEvent();
	if ( !event )
		return;

	if ( event->GetType() != CChoreoEvent::GESTURE )
	{
		Con_ColorPrintf( ERROR_R, ERROR_G, ERROR_B, "Absolute Tag:  Can only tag GESTURE events\n" );
		return;
	}

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

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

	strcpy( params.m_szInputText, "" );

	if ( !InputProperties( &params ) )
		return;

	if ( strlen( params.m_szInputText ) <= 0 )
	{
		Con_ColorPrintf( ERROR_R, ERROR_G, ERROR_B, "Timing Tag Name:  No name entered!\n" );
		return;
	}
	
	// Convert click to frac
	float t = GetTimeValueForMouse( m_nClickedX ) / event->GetDuration();
	float tshifted = event->GetShiftedTimeFromReferenceTime( t );

	g_pChoreoView->SetDirty( true );

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

	event->AddAbsoluteTag( CChoreoEvent::SHIFTED, params.m_szInputText, tshifted );
	event->AddAbsoluteTag( CChoreoEvent::PLAYBACK, params.m_szInputText, t );

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

	// Redraw this window
	redraw();
}

void GestureTool::OnRevert()
{
	CChoreoEvent *event = GetSafeEvent();
	if ( !event )
		return;

	if ( !event->GetNumAbsoluteTags( CChoreoEvent::PLAYBACK ) )
		return;

	if ( event->GetNumAbsoluteTags( CChoreoEvent::PLAYBACK ) !=
		 event->GetNumAbsoluteTags( CChoreoEvent::SHIFTED ) )
	{
		Assert( 0 );
		return;
	}

	g_pChoreoView->SetDirty( true );

	g_pChoreoView->PushUndo( "Revert Gesture Tags" );

	int c = event->GetNumAbsoluteTags( CChoreoEvent::PLAYBACK );
	for ( int i = 0; i < c; i++ )
	{
		CEventAbsoluteTag *shifted = event->GetAbsoluteTag( CChoreoEvent::SHIFTED, i );
		CEventAbsoluteTag *playback = event->GetAbsoluteTag( CChoreoEvent::PLAYBACK, i );

		shifted->SetTime( playback->GetTime() );
	}
		

	g_pChoreoView->PushRedo( "Revert Gesture Tags" );

	// Redraw this window
	redraw();
}

void GestureTool::OnDeleteTag( void )
{
	CChoreoEvent *event = GetSafeEvent();
	if ( !event )
		return;

	CEventAbsoluteTag *tag = IsMouseOverTag( m_nClickedX, m_nClickedY );
	if ( !tag )
		return;
	
	g_pChoreoView->SetDirty( true );

	g_pChoreoView->PushUndo( "Remove Gesture Tag" );

	char sz[ 512 ];
	Q_strncpy( sz, tag->GetName(), sizeof( sz ) );

	for ( int t = 0; t < CChoreoEvent::NUM_ABS_TAG_TYPES; t++ )
	{
		event->RemoveAbsoluteTag( (CChoreoEvent::AbsTagType)t, sz );
	}

	g_pChoreoView->PushRedo( "Remove Gesture Tags" );

	// Redraw this window
	redraw();
}

void GestureTool::DrawRelativeTags( CChoreoWidgetDrawHelper& drawHelper, RECT& rc )
{
	CChoreoEvent *gesture = GetSafeEvent();
	if ( !gesture )
		return;

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

	float starttime = GetTimeValueForMouse( 0 );
	float endtime = GetTimeValueForMouse( w2() );

	if ( endtime - starttime <= 0.0f )
		return;

	drawHelper.DrawColoredText( "Arial", 9, FW_NORMAL, RGB( 0, 100, 200 ), rc, "Timing Tags:" );

	// Loop through all events in scene

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

		if ( e->GetNumRelativeTags() <= 0 )
			continue;

		// See if time overlaps
		if ( !e->HasEndTime() )
			continue;

		if ( ( e->GetEndTime() - e->GetStartTime() ) < starttime )
			continue;

		if ( ( e->GetStartTime() - e->GetStartTime() ) > endtime )
			continue;

		DrawRelativeTagsForEvent( drawHelper, rc, gesture, e, starttime, endtime );
	}
}

//-----------------------------------------------------------------------------
// Purpose: 
// Input  : drawHelper - 
//			rc - 
//-----------------------------------------------------------------------------
void GestureTool::DrawRelativeTagsForEvent( CChoreoWidgetDrawHelper& drawHelper, RECT& rc, CChoreoEvent *gesture, CChoreoEvent *event, float starttime, float endtime )
{
	if ( !event )
		return;

	//drawHelper.DrawColoredText( "Arial", 9, FW_NORMAL, PEColor( COLOR_PHONEME_TIMING_TAG ), rc, "Timing Tags:" );

	for ( int i = 0; i < event->GetNumRelativeTags(); i++ )
	{
		CEventRelativeTag *tag = event->GetRelativeTag( i );
		if ( !tag )
			continue;

		// 
		float tagtime = ( event->GetStartTime() + tag->GetPercentage() * event->GetDuration() ) - gesture->GetStartTime();
		if ( tagtime < starttime || tagtime > endtime )
			continue;

		bool clipped = false;
		int left = GetPixelForTimeValue( tagtime, &clipped );
		if ( clipped )
			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, RGB( 0, 100, 200 ) );

		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, RGB( 0, 100, 200 ), rcText, tag->GetName() );
	}
}

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

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

	return pixels;

}

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

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

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

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

	m_nLastHPixelsNeeded = pixelsneeded;
}

//-----------------------------------------------------------------------------
// Purpose: 
// Output : float
//-----------------------------------------------------------------------------
float GestureTool::GetPixelsPerSecond( void )
{
	return m_flPixelsPerSecond * GetTimeZoomScale();
}


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

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

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

	m_bLayoutIsValid = false;
	redraw();
}

//-----------------------------------------------------------------------------
// Purpose: 
// Input  : st - 
//			ed - 
//-----------------------------------------------------------------------------
void GestureTool::GetStartAndEndTime( float& st, float& ed )
{
	st = m_nLeftOffset / GetPixelsPerSecond();
	ed = st + (float)w2() / GetPixelsPerSecond();
}

//-----------------------------------------------------------------------------
// Purpose: 
// Input  : time - 
//			*clipped - 
// Output : int
//-----------------------------------------------------------------------------
int GestureTool::GetPixelForTimeValue( float time, bool *clipped /*=NULL*/ )
{
	if ( clipped )
	{
		*clipped = false;
	}

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

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

	int pixel = ( int )( frac * w2() );
	return pixel;
}

//-----------------------------------------------------------------------------
// Purpose: 
// Input  : mx - 
//			clip - 
// Output : float
//-----------------------------------------------------------------------------
float GestureTool::GetTimeValueForMouse( int mx, bool clip /*=false*/)
{
	float st, ed;
	GetStartAndEndTime( st, ed );

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

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


//-----------------------------------------------------------------------------
// Purpose: 
// Output : float
//-----------------------------------------------------------------------------
float GestureTool::GetTimeZoomScale( void )
{
	return ( float )m_nTimeZoom / 100.0f;
}

//-----------------------------------------------------------------------------
// Purpose: 
// Input  : scale - 
//-----------------------------------------------------------------------------
void GestureTool::SetTimeZoomScale( int scale )
{
	m_nTimeZoom = scale;
}

void GestureTool::OnChangeScale( void )
{
	// Zoom time in  / out
	CInputParams params;
	memset( &params, 0, sizeof( params ) );

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

	Q_snprintf( params.m_szInputText, sizeof( params.m_szInputText ), "%.2f", (float)m_nTimeZoom / 100.0f );

	if ( !InputProperties( &params ) )
		return;

	m_nTimeZoom = clamp( (int)( 100.0f * atof( params.m_szInputText ) ), 1, MAX_TIME_ZOOM );

	m_nLastHPixelsNeeded = -1;
	m_nLeftOffset= 0;
	InvalidateLayout();
	Con_Printf( "Zoom factor %i %%\n", m_nTimeZoom );
}

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

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

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

	RECT rcClient;
	drawHelper.GetClientRect( rcClient );

	drawHelper.DrawColoredLine(
		COLOR_CHOREO_ENDTIME, PS_SOLID, 1,
		leftx, GetCaptionHeight() + 73, leftx, rcClient.bottom );

}