1764 lines
42 KiB
C++
1764 lines
42 KiB
C++
//========= Copyright Valve Corporation, All rights reserved. ============//
|
|
//
|
|
// Purpose:
|
|
//
|
|
// $NoKeywords: $
|
|
//=============================================================================//
|
|
#include "hlfaceposer.h"
|
|
#include <stdio.h>
|
|
#include "TimelineItem.h"
|
|
#include "choreowidgetdrawhelper.h"
|
|
#include "mathlib/mathlib.h"
|
|
#include "expressions.h"
|
|
#include "StudioModel.h"
|
|
#include "expclass.h"
|
|
#include "mathlib/mathlib.h"
|
|
#include "ExpressionTool.h"
|
|
#include "choreoevent.h"
|
|
#include "choreoscene.h"
|
|
#include "choreoactor.h"
|
|
#include "choreochannel.h"
|
|
#include "ChoreoView.h"
|
|
#include "ControlPanel.h"
|
|
#include "faceposer_models.h"
|
|
#include "MatSysWin.h"
|
|
#include "choreoviewcolors.h"
|
|
#include "ifaceposersound.h"
|
|
#include "curveeditorhelpers.h"
|
|
|
|
extern double realtime;
|
|
|
|
#define DOUBLE_CLICK_TIME 0.2
|
|
|
|
#define GROW_HANDLE_WIDTH 66
|
|
#define GROW_HANDLE_HEIGHT 8
|
|
#define GROW_HANDLE_INSETPIXELS 8
|
|
|
|
#define TIMELINEITEM_DEFAULT_HEIGHT 100
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose:
|
|
//-----------------------------------------------------------------------------
|
|
TimelineItem::TimelineItem( mxWindow *workspace )
|
|
{
|
|
m_pHelper = new CCurveEditorHelper< TimelineItem >( this );
|
|
|
|
m_pWorkspace = workspace;
|
|
|
|
m_nDragging = DRAGTYPE_NONE;
|
|
m_nLastX = 0;
|
|
m_nLastY = 0;
|
|
m_nStartX = 0;
|
|
m_nStartY = 0;
|
|
|
|
SetExpressionInfo( NULL, 0 );
|
|
|
|
m_nNumSelected = 0;
|
|
|
|
m_nEditType = 0;
|
|
|
|
SetCollapsed( false );
|
|
SetActive( false );
|
|
|
|
m_nUndoSetup = 0;
|
|
m_rcBounds.top = 0;
|
|
m_rcBounds.bottom = 0;
|
|
m_rcBounds.left = 0;
|
|
m_rcBounds.right = 0;
|
|
m_bVisible = false;
|
|
m_flLastClickTime = -1;
|
|
|
|
m_nCurrentHeight = TIMELINEITEM_DEFAULT_HEIGHT;
|
|
}
|
|
|
|
TimelineItem::~TimelineItem( void )
|
|
{
|
|
delete m_pHelper;
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose:
|
|
//-----------------------------------------------------------------------------
|
|
void TimelineItem::ResetHeight()
|
|
{
|
|
m_nCurrentHeight = TIMELINEITEM_DEFAULT_HEIGHT;
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose:
|
|
// Input : mx -
|
|
// Output : float
|
|
//-----------------------------------------------------------------------------
|
|
float TimelineItem::GetTimeForMouse( int mx, bool clip /*= false*/ )
|
|
{
|
|
float start, end;
|
|
g_pExpressionTool->GetStartAndEndTime( start, end );
|
|
|
|
if ( clip )
|
|
{
|
|
if ( mx < m_rcBounds.left )
|
|
{
|
|
return start;
|
|
}
|
|
else if ( mx >= m_rcBounds.right )
|
|
{
|
|
return end;
|
|
}
|
|
}
|
|
|
|
float frac = (float)( mx - m_rcBounds.left ) / (float)( m_rcBounds.right - m_rcBounds.left );
|
|
float t = start + frac * ( end - start );
|
|
return t;
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose:
|
|
// Input : t -
|
|
// Output : int
|
|
//-----------------------------------------------------------------------------
|
|
int TimelineItem::GetMouseForTime( float t, bool *clipped /*= NULL*/ )
|
|
{
|
|
float start, end;
|
|
g_pExpressionTool->GetStartAndEndTime( start, end );
|
|
|
|
float frac = ( t - start ) / ( end - start );
|
|
|
|
if ( frac < 0.0 || frac > 1.0 )
|
|
{
|
|
if ( clipped )
|
|
{
|
|
*clipped = true;
|
|
}
|
|
}
|
|
|
|
int mx = m_rcBounds.left + ( int ) ( frac * (float)( m_rcBounds.right - m_rcBounds.left ) );
|
|
|
|
return mx;
|
|
}
|
|
|
|
int TimelineItem::NumSamples()
|
|
{
|
|
CFlexAnimationTrack *track = GetSafeTrack();
|
|
if ( !track )
|
|
return 0;
|
|
|
|
// Aggregate both types of tracks together
|
|
return track->GetNumSamples( 0 ) + track->GetNumSamples( 1 );
|
|
// return track->GetNumSamples( m_nEditType );
|
|
}
|
|
|
|
CExpressionSample *TimelineItem::GetSample( int idx )
|
|
{
|
|
CFlexAnimationTrack *track = GetSafeTrack();
|
|
if ( !track )
|
|
return NULL;
|
|
|
|
if ( idx >= track->GetNumSamples( 0 ) )
|
|
{
|
|
// Rebase and look at left/right track instead
|
|
idx -= track->GetNumSamples( 0 );
|
|
return track->GetSample( idx, 1 );
|
|
}
|
|
return track->GetSample( idx, 0 );
|
|
}
|
|
|
|
CExpressionSample *TimelineItem::GetSampleUnderMouse( int mx, int my, float tolerance /*= FP_TL_SELECTION_TOLERANCE*/ )
|
|
{
|
|
CFlexAnimationTrack *track = GetSafeTrack();
|
|
if ( !track )
|
|
return NULL;
|
|
|
|
CChoreoEvent *e = track->GetEvent();
|
|
if ( !e )
|
|
return NULL;
|
|
|
|
float closest_dist = 9999999.f;
|
|
CExpressionSample *bestsample = NULL;
|
|
|
|
// Add a sample point
|
|
int height = m_rcBounds.bottom - m_rcBounds.top;
|
|
|
|
mx += m_rcBounds.left;
|
|
|
|
for ( int i = 0; i < track->GetNumSamples( m_nEditType ); i++ )
|
|
{
|
|
CExpressionSample *sample = track->GetSample( i, m_nEditType );
|
|
|
|
bool clipped = false;
|
|
int px = GetMouseForTime( sample->time, &clipped );
|
|
int py = height * ( 1.0f - sample->value );
|
|
|
|
int dx = px - mx;
|
|
int dy = py - my;
|
|
|
|
float dist = sqrt( (float)(dx * dx + dy * dy) );
|
|
if ( dist < closest_dist )
|
|
{
|
|
bestsample = sample;
|
|
closest_dist = dist;
|
|
}
|
|
}
|
|
|
|
// Not close to any of them!!!
|
|
if ( ( tolerance != 0.0f ) &&
|
|
( closest_dist > tolerance ) )
|
|
return NULL;
|
|
|
|
return bestsample;
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose:
|
|
//-----------------------------------------------------------------------------
|
|
void TimelineItem::DeselectAll( void )
|
|
{
|
|
g_pExpressionTool->DeselectAll();
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose:
|
|
//-----------------------------------------------------------------------------
|
|
void TimelineItem::SelectAll( void )
|
|
{
|
|
CFlexAnimationTrack *track = GetSafeTrack();
|
|
if ( !track )
|
|
return;
|
|
|
|
for ( int t = 0; t < 2; t++ )
|
|
{
|
|
for ( int i = 0; i < track->GetNumSamples( t ); i++ )
|
|
{
|
|
CExpressionSample *sample = track->GetSample( i, t );
|
|
sample->selected = true;
|
|
}
|
|
}
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose:
|
|
//-----------------------------------------------------------------------------
|
|
void TimelineItem::Delete( void )
|
|
{
|
|
g_pExpressionTool->DeleteSelectedSamples();
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose:
|
|
// Input : sample -
|
|
//-----------------------------------------------------------------------------
|
|
void TimelineItem::AddSample( CExpressionSample const& sample )
|
|
{
|
|
CFlexAnimationTrack *track = GetSafeTrack();
|
|
if ( !track )
|
|
return;
|
|
|
|
PreDataChanged( "Add sample point" );
|
|
|
|
track->AddSample( sample.time, sample.value, m_nEditType );
|
|
track->Resort( m_nEditType );
|
|
|
|
SetActive( true );
|
|
|
|
PostDataChanged( "Add sample point" );
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose:
|
|
//-----------------------------------------------------------------------------
|
|
int TimelineItem::CountSelected( void )
|
|
{
|
|
m_nNumSelected = m_pHelper->CountSelected( false );
|
|
return m_nNumSelected;
|
|
}
|
|
|
|
void TimelineItem::SetMousePositionForEvent( mxEvent *event )
|
|
{
|
|
POINT pt;
|
|
GetCursorPos( &pt );
|
|
ScreenToClient( (HWND)m_pWorkspace->getHandle(), &pt );
|
|
|
|
pt.x -= m_rcBounds.left;
|
|
pt.y -= m_rcBounds.top;
|
|
|
|
event->x = pt.x;
|
|
event->y = pt.y;
|
|
}
|
|
|
|
int TimelineItem::handleEvent( mxEvent *event )
|
|
{
|
|
int iret = 0;
|
|
|
|
// Give helper a shot at the event
|
|
if ( m_pHelper->HelperHandleEvent( event ) )
|
|
{
|
|
return 1;
|
|
}
|
|
|
|
switch ( event->event )
|
|
{
|
|
case mxEvent::KeyDown:
|
|
{
|
|
switch ( event->key )
|
|
{
|
|
default:
|
|
iret = g_pChoreoView->HandleZoomKey( g_pExpressionTool, event->key );
|
|
break;
|
|
case VK_ESCAPE:
|
|
DeselectAll();
|
|
DrawSelf();
|
|
break;
|
|
case VK_DELETE:
|
|
Delete();
|
|
DrawSelf();
|
|
break;
|
|
case 'C':
|
|
Copy();
|
|
DrawSelf();
|
|
break;
|
|
case 'V':
|
|
Paste();
|
|
DrawSelf();
|
|
break;
|
|
case 'J':
|
|
{
|
|
g_pExpressionTool->OnCopyToFlex( g_pExpressionTool->GetScrubberSceneTime(), true );
|
|
}
|
|
break;
|
|
case 'K':
|
|
{
|
|
g_pExpressionTool->OnCopyFromFlex( g_pExpressionTool->GetScrubberSceneTime(), false );
|
|
}
|
|
break;
|
|
case 188: // VK_OEM_COMMA:
|
|
{
|
|
g_pExpressionTool->SetScrubTargetTime( 0.0f );
|
|
}
|
|
break;
|
|
case 190: // VK_OEM_PERIOD:
|
|
{
|
|
CChoreoScene *scene = g_pChoreoView->GetScene();
|
|
if ( scene )
|
|
{
|
|
g_pExpressionTool->SetScrubTargetTime( scene->FindStopTime() );
|
|
}
|
|
}
|
|
break;
|
|
case VK_LEFT:
|
|
{
|
|
CChoreoScene *scene = g_pChoreoView->GetScene();
|
|
if ( scene && scene->GetSceneFPS() > 0 )
|
|
{
|
|
float curscrub = g_pExpressionTool->GetScrub();
|
|
curscrub -= ( 1.0f / (float)scene->GetSceneFPS() );
|
|
curscrub = max( curscrub, 0.0f );
|
|
g_pExpressionTool->SetScrubTargetTime( curscrub );
|
|
}
|
|
}
|
|
break;
|
|
case VK_RIGHT:
|
|
{
|
|
CChoreoScene *scene = g_pChoreoView->GetScene();
|
|
if ( scene && scene->GetSceneFPS() > 0 )
|
|
{
|
|
float curscrub = g_pExpressionTool->GetScrub();
|
|
curscrub += ( 1.0f / (float)scene->GetSceneFPS() );
|
|
curscrub = min( curscrub, scene->FindStopTime() );
|
|
g_pExpressionTool->SetScrubTargetTime( curscrub );
|
|
}
|
|
}
|
|
break;
|
|
case 191:
|
|
{
|
|
if ( g_pChoreoView->IsPlayingScene() )
|
|
{
|
|
g_pChoreoView->StopScene();
|
|
}
|
|
}
|
|
break;
|
|
}
|
|
iret = 1;
|
|
}
|
|
break;
|
|
case mxEvent::KeyUp:
|
|
{
|
|
switch ( event->key )
|
|
{
|
|
case VK_SPACE:
|
|
{
|
|
CFlexAnimationTrack *track = GetSafeTrack();
|
|
if ( track && track->IsComboType() )
|
|
{
|
|
SetEditType( m_nEditType == 0 ? 1 : 0 );
|
|
DrawSelf();
|
|
}
|
|
}
|
|
break;
|
|
}
|
|
iret = 1;
|
|
}
|
|
break;
|
|
case mxEvent::MouseDown:
|
|
{
|
|
sound->Flush();
|
|
|
|
SetFocus( (HWND)g_pExpressionTool->getHandle() );
|
|
|
|
int height = m_rcBounds.bottom - m_rcBounds.top;
|
|
|
|
bool rightbutton = ( event->buttons & mxEvent::MouseRightButton ) ? true : false;
|
|
|
|
if ( m_nDragging == DRAGTYPE_NONE )
|
|
{
|
|
bool ctrlDown = ( event->modifiers & mxEvent::KeyCtrl ) ? true : false;
|
|
|
|
CExpressionSample *sample = GetSampleUnderMouse( event->x, event->y, ctrlDown ? FP_TL_ADDSAMPLE_TOLERANCE : FP_TL_SELECTION_TOLERANCE );
|
|
|
|
if ( IsMouseOverGrowHandle( (short)event->x, (short)event->y ) )
|
|
{
|
|
m_nDragging = DRAGTYPE_GROW;
|
|
m_nLastX = (short)event->x;
|
|
m_nLastY = (short)event->y;
|
|
|
|
m_nStartX = m_nLastX;
|
|
m_nStartY = m_nLastY;
|
|
|
|
MouseDrag( (short)event->x, (short)event->y, event->modifiers );
|
|
|
|
DrawGrowRect();
|
|
}
|
|
else if ( sample )
|
|
{
|
|
if ( event->modifiers & mxEvent::KeyShift )
|
|
{
|
|
sample->selected = !sample->selected;
|
|
DrawSelf();
|
|
}
|
|
else if ( sample->selected )
|
|
{
|
|
m_nDragging = rightbutton ? DRAGTYPE_MOVEPOINTS_TIME : DRAGTYPE_MOVEPOINTS_VALUE;
|
|
m_nLastX = (short)event->x;
|
|
m_nLastY = (short)event->y;
|
|
|
|
m_nStartX = m_nLastX;
|
|
m_nStartY = m_nLastY;
|
|
|
|
PreDataChanged( "Move sample point(s)" );
|
|
|
|
MouseDrag( (short)event->x, (short)event->y, event->modifiers );
|
|
|
|
DrawSelf();
|
|
}
|
|
else
|
|
{
|
|
if ( !( event->modifiers & mxEvent::KeyShift ) )
|
|
{
|
|
DeselectAll();
|
|
DrawSelf();
|
|
}
|
|
|
|
m_nDragging = DRAGTYPE_SELECTION;
|
|
m_nLastX = (short)event->x;
|
|
m_nLastY = (short)event->y;
|
|
|
|
m_nStartX = m_nLastX;
|
|
m_nStartY = m_nLastY;
|
|
|
|
MouseDrag( (short)event->x, (short)event->y, event->modifiers );
|
|
|
|
DrawFocusRect();
|
|
}
|
|
}
|
|
else if ( event->modifiers & mxEvent::KeyCtrl )
|
|
{
|
|
CChoreoEvent *e = g_pExpressionTool->GetSafeEvent();
|
|
if ( e )
|
|
{
|
|
// Add a sample point
|
|
float t = GetTimeForMouse( (short)event->x + m_rcBounds.left );
|
|
|
|
CExpressionSample sample;
|
|
sample.time = FacePoser_SnapTime( t );
|
|
sample.value = 1.0f - (float)( (short)( event->y ) ) / (float)height;
|
|
sample.selected = false;
|
|
|
|
AddSample( sample );
|
|
|
|
DrawSelf();
|
|
}
|
|
}
|
|
else
|
|
{
|
|
if ( rightbutton )
|
|
{
|
|
POINT pt;
|
|
pt.x = event->x;
|
|
pt.y = event->y;
|
|
ClientToScreen( (HWND)m_pWorkspace->getHandle(), &pt );
|
|
ScreenToClient( (HWND)g_pExpressionTool->getHandle(), &pt );
|
|
event->x = pt.x;
|
|
event->y = pt.y;
|
|
g_pExpressionTool->ShowContextMenu( event, true );
|
|
return iret;
|
|
}
|
|
|
|
if ( !( event->modifiers & mxEvent::KeyShift ) )
|
|
{
|
|
DeselectAll();
|
|
DrawSelf();
|
|
}
|
|
|
|
m_nDragging = DRAGTYPE_SELECTION;
|
|
m_nLastX = (short)event->x;
|
|
m_nLastY = (short)event->y;
|
|
|
|
m_nStartX = m_nLastX;
|
|
m_nStartY = m_nLastY;
|
|
|
|
MouseDrag( (short)event->x, (short)event->y, event->modifiers );
|
|
|
|
DrawFocusRect();
|
|
}
|
|
}
|
|
iret = 1;
|
|
}
|
|
break;
|
|
case mxEvent::MouseDrag:
|
|
case mxEvent::MouseMove:
|
|
{
|
|
if ( m_nDragging != DRAGTYPE_NONE )
|
|
{
|
|
if ( m_nDragging == DRAGTYPE_SELECTION )
|
|
{
|
|
DrawFocusRect();
|
|
}
|
|
else if ( m_nDragging == DRAGTYPE_GROW )
|
|
{
|
|
DrawGrowRect();
|
|
}
|
|
|
|
MouseDrag( (short)event->x, (short)event->y, event->modifiers );
|
|
|
|
if ( m_nDragging == DRAGTYPE_SELECTION )
|
|
{
|
|
DrawFocusRect();
|
|
}
|
|
else if ( m_nDragging == DRAGTYPE_GROW )
|
|
{
|
|
DrawGrowRect();
|
|
}
|
|
|
|
if ( m_nDragging == DRAGTYPE_MOVEPOINTS_TIME ||
|
|
m_nDragging == DRAGTYPE_MOVEPOINTS_VALUE )
|
|
{
|
|
DrawSelf();
|
|
}
|
|
}
|
|
else
|
|
{
|
|
// See if anything is selected
|
|
CountSelected();
|
|
if ( m_nNumSelected <= 0 && g_pExpressionTool->IsFocusItem( this ) )
|
|
{
|
|
// Nothing selected
|
|
// Draw auto highlight
|
|
DrawAutoHighlight( event );
|
|
}
|
|
}
|
|
iret = 1;
|
|
}
|
|
break;
|
|
case mxEvent::MouseUp:
|
|
{
|
|
bool overgrow = IsMouseOverGrowHandle( (short)event->x, (short)event->y );
|
|
|
|
if ( m_nDragging != DRAGTYPE_NONE )
|
|
{
|
|
if ( m_nDragging == DRAGTYPE_SELECTION )
|
|
{
|
|
DrawFocusRect();
|
|
}
|
|
else if ( m_nDragging == DRAGTYPE_GROW )
|
|
{
|
|
DrawGrowRect();
|
|
}
|
|
|
|
MouseDrag( (short)event->x, (short)event->y, event->modifiers, true );
|
|
|
|
if ( m_nDragging == DRAGTYPE_GROW )
|
|
{
|
|
// Finish grow by resizing control
|
|
int desiredheight = m_nCurrentHeight + event->y - m_nStartY;
|
|
if ( desiredheight >= 10 )
|
|
{
|
|
m_nCurrentHeight = desiredheight;
|
|
g_pExpressionTool->LayoutItems( true );
|
|
}
|
|
}
|
|
else if ( m_nDragging != DRAGTYPE_MOVEPOINTS_VALUE &&
|
|
m_nDragging != DRAGTYPE_MOVEPOINTS_TIME )
|
|
{
|
|
SelectPoints();
|
|
}
|
|
else
|
|
{
|
|
PostDataChanged( "Move sample point(s)" );
|
|
}
|
|
|
|
m_nDragging = DRAGTYPE_NONE;
|
|
|
|
DrawSelf();
|
|
}
|
|
|
|
bool rightbutton = ( event->buttons & mxEvent::MouseRightButton ) ? true : false;
|
|
bool shift = ( event->modifiers & mxEvent::KeyShift ) ? true : false;
|
|
bool ctrl = ( event->modifiers & mxEvent::KeyCtrl ) ? true : false;
|
|
|
|
if ( !rightbutton && !shift && !ctrl )
|
|
{
|
|
if ( realtime - m_flLastClickTime < DOUBLE_CLICK_TIME )
|
|
{
|
|
if ( overgrow || IsCollapsed() )
|
|
{
|
|
OnDoubleClicked();
|
|
}
|
|
}
|
|
|
|
m_flLastClickTime = realtime;
|
|
}
|
|
|
|
iret = 1;
|
|
}
|
|
break;
|
|
}
|
|
|
|
return iret;
|
|
}
|
|
|
|
void TimelineItem::MouseDrag( int x, int y, int modifiers, bool snap /*=false*/ )
|
|
{
|
|
if ( m_nDragging == DRAGTYPE_NONE )
|
|
return;
|
|
|
|
int width = m_rcBounds.right - m_rcBounds.left;
|
|
int height = m_rcBounds.bottom - m_rcBounds.top;
|
|
|
|
if ( m_nDragging == DRAGTYPE_MOVEPOINTS_TIME ||
|
|
m_nDragging == DRAGTYPE_MOVEPOINTS_VALUE )
|
|
{
|
|
int dx = x - m_nLastX;
|
|
int dy = y - m_nLastY;
|
|
|
|
if ( !( modifiers & mxEvent::KeyCtrl ) )
|
|
{
|
|
// Zero out motion on other axis
|
|
if ( m_nDragging == DRAGTYPE_MOVEPOINTS_VALUE )
|
|
{
|
|
dx = 0;
|
|
x = m_nLastX;
|
|
}
|
|
else
|
|
{
|
|
dy = 0;
|
|
y = m_nLastY;
|
|
}
|
|
}
|
|
|
|
float dfdx = (float)dx / g_pExpressionTool->GetPixelsPerSecond();
|
|
float dfdy = (float)dy / (float)height;
|
|
|
|
g_pExpressionTool->MoveSelectedSamples( dfdx, dfdy, snap );
|
|
|
|
// Update the scrubber
|
|
if ( (float)width > 0 )
|
|
{
|
|
float t = GetTimeForMouse( x + m_rcBounds.left );
|
|
g_pExpressionTool->ForceScrubPosition( t );
|
|
|
|
g_pMatSysWindow->Frame();
|
|
}
|
|
}
|
|
|
|
m_nLastX = x;
|
|
m_nLastY = y;
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose:
|
|
//-----------------------------------------------------------------------------
|
|
void TimelineItem::DrawFocusRect( void )
|
|
{
|
|
RECT rcFocus;
|
|
|
|
rcFocus.left = m_nStartX < m_nLastX ? m_nStartX : m_nLastX;
|
|
rcFocus.right = m_nStartX < m_nLastX ? m_nLastX : m_nStartX;
|
|
|
|
rcFocus.top = m_nStartY < m_nLastY ? m_nStartY : m_nLastY;
|
|
rcFocus.bottom = m_nStartY < m_nLastY ? m_nLastY : m_nStartY;
|
|
|
|
POINT offset;
|
|
offset.x = m_rcBounds.left;
|
|
offset.y = m_rcBounds.top;
|
|
ClientToScreen( (HWND)m_pWorkspace->getHandle(), &offset );
|
|
OffsetRect( &rcFocus, offset.x, offset.y );
|
|
|
|
HDC dc = GetDC( NULL );
|
|
|
|
::DrawFocusRect( dc, &rcFocus );
|
|
|
|
ReleaseDC( NULL, dc );
|
|
}
|
|
|
|
void TimelineItem::DrawSelf( void )
|
|
{
|
|
CChoreoWidgetDrawHelper drawHelper( m_pWorkspace, m_rcBounds );
|
|
Draw( drawHelper );
|
|
}
|
|
|
|
void TimelineItem::Draw( CChoreoWidgetDrawHelper& drawHelper )
|
|
{
|
|
CFlexAnimationTrack *track = GetSafeTrack();
|
|
if ( !track )
|
|
return;
|
|
|
|
CChoreoEvent *e = track->GetEvent();
|
|
if ( !e )
|
|
return;
|
|
|
|
Assert( e->HasEndTime() );
|
|
|
|
bool active = track && ( IsValid() || IsActive() );
|
|
|
|
float starttime;
|
|
float endtime;
|
|
|
|
g_pExpressionTool->GetStartAndEndTime( starttime, endtime );
|
|
|
|
CountSelected();
|
|
int scount = GetNumSelected();
|
|
|
|
COLORREF bgColor = RGB( 230, 230, 200 );
|
|
if ( IsCollapsed() && active )
|
|
{
|
|
bgColor = RGB( 200, 230, 200 );
|
|
}
|
|
|
|
RECT rcClient = m_rcBounds;
|
|
|
|
drawHelper.DrawFilledRect( bgColor, rcClient );
|
|
|
|
COLORREF gray = RGB( 200, 200, 200 );
|
|
|
|
DrawEventEnd( drawHelper );
|
|
|
|
DrawRelativeTags( drawHelper );
|
|
if ( !IsCollapsed() && track )
|
|
{
|
|
if ( m_nEditType == 1 )
|
|
{
|
|
float zero = track->GetZeroValue( m_nEditType, true );
|
|
|
|
drawHelper.DrawColoredLine( RGB( 180, 200, 220 ), PS_SOLID, 1,
|
|
rcClient.left, ( rcClient.top * zero + rcClient.bottom * (1 - zero)) ,
|
|
rcClient.right, ( rcClient.top * zero + rcClient.bottom * (1 - zero)) );
|
|
}
|
|
|
|
drawHelper.DrawOutlinedRect( RGB( 100, 150, 200 ), PS_SOLID, 1, rcClient );
|
|
|
|
// Draw grow handle into background...
|
|
if ( CanHaveGrowHandle() )
|
|
{
|
|
RECT handleRect;
|
|
GetGrowHandleRect( handleRect );
|
|
DrawGrowHandle( drawHelper, handleRect );
|
|
}
|
|
|
|
// Draw left/right underneath amount so go backbard
|
|
for ( int type = ( track->IsComboType() ? 1 : 0 ); type >= 0; type-- )
|
|
{
|
|
COLORREF lineColor = ( type == m_nEditType ) ? RGB( 0, 0, 255 ) : gray;
|
|
COLORREF shadowColor = ( type == m_nEditType ) ? RGB( 150, 150, 250 ) : gray;
|
|
COLORREF dotColor = ( type == m_nEditType ) ? RGB( 0, 0, 255 ) : gray;
|
|
COLORREF dotColorSelected = ( type == m_nEditType ) ? RGB( 240, 80, 20 ) : gray;
|
|
|
|
int height = rcClient.bottom - rcClient.top;
|
|
int bottom = rcClient.bottom;
|
|
|
|
// Fixme, could look at 1st derivative and do more sampling at high rate of change?
|
|
// or near actual sample points!
|
|
float linelength = g_pExpressionTool->IsFocusItem( this ) ? 2.0f : 8.0f;
|
|
|
|
float timestepperpixel = linelength / g_pExpressionTool->GetPixelsPerSecond();
|
|
|
|
float stoptime = min( endtime, e->GetDuration() );
|
|
|
|
float prev_t = starttime;
|
|
float prev_value = track->GetFracIntensity( prev_t, type );
|
|
|
|
CUtlVector< POINT > segments;
|
|
|
|
/*
|
|
if (type == m_nEditType)
|
|
{
|
|
// draw hermite version of time step
|
|
float i0, i1, i2;
|
|
float time10hz = starttime;
|
|
|
|
i0 = track->GetFracIntensity( time10hz, type );
|
|
i1 = i0;
|
|
time10hz = starttime + 0.1;
|
|
i2 = track->GetFracIntensity( time10hz, type );;
|
|
|
|
for ( float t = starttime; t <= stoptime; t += timestepperpixel )
|
|
{
|
|
while (t >= time10hz)
|
|
{
|
|
time10hz += 0.1;
|
|
i0 = i1;
|
|
i1 = i2;
|
|
i2 = track->GetFracIntensity( time10hz, type );;
|
|
}
|
|
|
|
float value = Hermite_Spline( i0, i1, i2, (t - time10hz + 0.1) / 0.1 );
|
|
|
|
int prevx, x;
|
|
|
|
bool clipped1, clipped2;
|
|
x = GetMouseForTime( t, &clipped1 );
|
|
prevx = GetMouseForTime( prev_t, &clipped2 );
|
|
|
|
//if ( !clipped1 && !clipped2 )
|
|
{
|
|
// Draw segment
|
|
//drawHelper.DrawColoredLine( lineColor, PS_SOLID, 1,
|
|
// prevx, bottom - prev_value * height,
|
|
// x, bottom - value * height );
|
|
|
|
POINT pt;
|
|
|
|
if ( segments.Count() == 0 )
|
|
{
|
|
pt.x = prevx;
|
|
pt.y = bottom - prev_value * height;
|
|
|
|
segments.AddToTail( pt );
|
|
}
|
|
|
|
pt.x = x;
|
|
pt.y = bottom - value * height;
|
|
|
|
segments.AddToTail( pt );
|
|
}
|
|
|
|
prev_t = t;
|
|
prev_value = value;
|
|
}
|
|
|
|
if ( segments.Count() >= 2 )
|
|
{
|
|
drawHelper.DrawColoredPolyLine( shadowColor, PS_SOLID, 1, segments );
|
|
}
|
|
|
|
segments.RemoveAll();
|
|
}
|
|
*/
|
|
for ( float t = starttime; t <= stoptime; t += timestepperpixel )
|
|
{
|
|
float value = track->GetFracIntensity( t, type );
|
|
|
|
int prevx, x;
|
|
|
|
bool clipped1, clipped2;
|
|
x = GetMouseForTime( t, &clipped1 );
|
|
prevx = GetMouseForTime( prev_t, &clipped2 );
|
|
|
|
//if ( !clipped1 && !clipped2 )
|
|
{
|
|
// Draw segment
|
|
//drawHelper.DrawColoredLine( lineColor, PS_SOLID, 1,
|
|
// prevx, bottom - prev_value * height,
|
|
// x, bottom - value * height );
|
|
|
|
POINT pt;
|
|
|
|
if ( segments.Count() == 0 )
|
|
{
|
|
pt.x = prevx;
|
|
pt.y = bottom - prev_value * height;
|
|
|
|
segments.AddToTail( pt );
|
|
}
|
|
|
|
pt.x = x;
|
|
pt.y = bottom - value * height;
|
|
|
|
segments.AddToTail( pt );
|
|
}
|
|
|
|
prev_t = t;
|
|
prev_value = value;
|
|
}
|
|
|
|
if ( segments.Count() >= 2 )
|
|
{
|
|
drawHelper.DrawColoredPolyLine( lineColor, PS_SOLID, 1, segments );
|
|
}
|
|
|
|
for ( int sample = 0; sample < track->GetNumSamples( type ); sample++ )
|
|
{
|
|
bool dummy;
|
|
CExpressionSample *start = track->GetBoundedSample( sample, dummy, type );
|
|
|
|
/*
|
|
int pixel = (int)( ( start->time / event_time ) * width + 0.5f);
|
|
int x = m_rcBounds.left + pixel;
|
|
float roundedfrac = (float)pixel / (float)width;
|
|
*/
|
|
float value = start->value; // track->GetFracIntensity( start->time, type );
|
|
bool clipped = false;
|
|
int x = GetMouseForTime( start->time, &clipped );
|
|
if ( clipped )
|
|
continue;
|
|
int y = bottom - value * height;
|
|
|
|
int dotsize = 6;
|
|
int dotSizeSelected = 6;
|
|
|
|
COLORREF clr = dotColor;
|
|
COLORREF clrSelected = dotColorSelected;
|
|
|
|
drawHelper.DrawCircle(
|
|
start->selected ? clrSelected : clr,
|
|
x, y,
|
|
start->selected ? dotSizeSelected : dotsize,
|
|
true );
|
|
|
|
|
|
if ( !start->selected )
|
|
continue;
|
|
|
|
if ( start->GetCurveType() == CURVE_DEFAULT )
|
|
continue;
|
|
|
|
// Draw curve type indicator...
|
|
char sz[ 128 ];
|
|
Q_snprintf( sz, sizeof( sz ), "%s", Interpolator_NameForCurveType( start->GetCurveType(), true ) );
|
|
RECT rc;
|
|
int fontSize = 9;
|
|
rc.top = clamp( y + 5, rcClient.top + 2, rcClient.bottom - 2 - fontSize );
|
|
rc.bottom = rc.top + fontSize + 1;
|
|
rc.left = x - 75;
|
|
rc.right = x + 175;
|
|
drawHelper.DrawColoredText( "Arial", fontSize, 500, shadowColor, rc, sz );
|
|
}
|
|
}
|
|
}
|
|
|
|
if ( track && track->IsComboType() && !IsCollapsed() )
|
|
{
|
|
RECT title = rcClient;
|
|
title.left += 10;
|
|
title.top += 14;
|
|
title.bottom = title.top + 9;
|
|
|
|
char sz[ 128 ];
|
|
|
|
if ( m_nEditType == 1 )
|
|
{
|
|
sprintf( sz, "left" );
|
|
|
|
drawHelper.DrawColoredText( "Arial", 9, 500, RGB( 0, 0, 255 ), title, sz );
|
|
|
|
sprintf( sz, "right" );
|
|
|
|
title.top = rcClient.bottom - 22;
|
|
title.bottom = rcClient.bottom;
|
|
|
|
drawHelper.DrawColoredText( "Arial", 9, 500, RGB( 0, 0, 255 ), title, sz );
|
|
}
|
|
|
|
int mid = ( rcClient.top + rcClient.bottom ) / 2;
|
|
|
|
title.top = mid - 10;
|
|
title.bottom = mid;
|
|
|
|
sprintf( sz, "editmode: <%s>", m_nEditType == 0 ? "amount" : "left/right" );
|
|
|
|
drawHelper.DrawColoredText( "Arial", 9, 500, RGB( 0, 0, 255 ), title, sz );
|
|
}
|
|
|
|
if ( track )
|
|
{
|
|
RECT title = rcClient;
|
|
title.left += 2;
|
|
title.top += 2;
|
|
title.bottom = title.top + 9;
|
|
|
|
char const *name = track->GetFlexControllerName();
|
|
char sz[ 128 ];
|
|
|
|
if ( scount > 0 )
|
|
{
|
|
sprintf( sz, "{%i} - ", scount );
|
|
|
|
int len = drawHelper.CalcTextWidth( "Arial", 9, 500, sz );
|
|
drawHelper.DrawColoredText( "Arial", 9, 500,
|
|
RGB( 120, 120, 0 ), title, sz );
|
|
|
|
title.left += len + 2;
|
|
}
|
|
|
|
sprintf( sz, "%s -", name );
|
|
|
|
int len = drawHelper.CalcTextWidth( "Arial", 9, 500, sz );
|
|
|
|
drawHelper.DrawColoredText( "Arial", 9, 500,
|
|
active ? RGB( 0, 150, 100 ) : RGB( 100, 100, 100 ),
|
|
title, sz );
|
|
|
|
sprintf( sz, "%s", IsActive() ? "enabled" : "disabled" );
|
|
|
|
title.left += len + 2;
|
|
|
|
len = drawHelper.CalcTextWidth( "Arial", 9, 500, sz );
|
|
drawHelper.DrawColoredText( "Arial", 9, 500,
|
|
active ? RGB( 0, 150, 100 ) : RGB( 100, 100, 100 ),
|
|
title, sz );
|
|
|
|
if ( active )
|
|
{
|
|
title.left += len + 2;
|
|
|
|
sprintf( sz, " <%i>", track->GetNumSamples( 0 ) );
|
|
|
|
len = drawHelper.CalcTextWidth( "Arial", 9, 500, sz );
|
|
drawHelper.DrawColoredText( "Arial", 9, 500, RGB( 220, 0, 00 ), title, sz );
|
|
}
|
|
}
|
|
}
|
|
|
|
void TimelineItem::DrawAutoHighlight( mxEvent *event )
|
|
{
|
|
if ( IsCollapsed() )
|
|
return;
|
|
|
|
CFlexAnimationTrack *track = GetSafeTrack();
|
|
if ( !track )
|
|
return;
|
|
|
|
CExpressionSample *hover = GetSampleUnderMouse( event->x, event->y, 0.0f );
|
|
CChoreoWidgetDrawHelper drawHelper( m_pWorkspace, m_rcBounds, true );
|
|
|
|
RECT rcClient = m_rcBounds;
|
|
|
|
// Draw left/right underneath amount so go backbard
|
|
int type = m_nEditType;
|
|
|
|
COLORREF dotColor = RGB( 0, 0, 255 );
|
|
COLORREF dotColorSelected = RGB( 240, 80, 20 );
|
|
COLORREF clrHighlighted = RGB( 0, 200, 0 );
|
|
|
|
int height = rcClient.bottom - rcClient.top;
|
|
int bottom = rcClient.bottom;
|
|
|
|
int dotsize = 6;
|
|
int dotSizeSelected = 6;
|
|
int dotSizeHighlighted = 6;
|
|
|
|
COLORREF clr = dotColor;
|
|
COLORREF clrSelected = dotColorSelected;
|
|
COLORREF bgColor = RGB( 230, 230, 200 );
|
|
|
|
// Fixme, could look at 1st derivative and do more sampling at high rate of change?
|
|
// or near actual sample points!
|
|
for ( int sample = 0; sample < track->GetNumSamples( type ); sample++ )
|
|
{
|
|
bool dummy;
|
|
CExpressionSample *start = track->GetBoundedSample( sample, dummy, type );
|
|
|
|
float value = start->value;
|
|
bool clipped = false;
|
|
int x = GetMouseForTime( start->time, &clipped );
|
|
if ( clipped )
|
|
continue;
|
|
int y = bottom - value * height;
|
|
|
|
if ( hover == start )
|
|
{
|
|
drawHelper.DrawCircle(
|
|
bgColor,
|
|
x, y,
|
|
dotSizeHighlighted,
|
|
true );
|
|
|
|
drawHelper.DrawCircle(
|
|
clrHighlighted,
|
|
x, y,
|
|
dotSizeHighlighted,
|
|
false );
|
|
|
|
|
|
}
|
|
else
|
|
{
|
|
drawHelper.DrawCircle(
|
|
start->selected ? clrSelected : clr,
|
|
x, y,
|
|
start->selected ? dotSizeSelected : dotsize,
|
|
true );
|
|
}
|
|
}
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose:
|
|
// Input : drawHelper -
|
|
//-----------------------------------------------------------------------------
|
|
void TimelineItem::DrawRelativeTags( CChoreoWidgetDrawHelper& drawHelper )
|
|
{
|
|
CFlexAnimationTrack *track = GetSafeTrack();
|
|
if ( !track )
|
|
return;
|
|
|
|
CChoreoEvent *event = track->GetEvent();
|
|
if ( !event )
|
|
return;
|
|
|
|
float duration = event->GetDuration();
|
|
|
|
if ( duration <= 0.0f )
|
|
return;
|
|
|
|
CChoreoScene *scene = g_pChoreoView->GetScene();
|
|
if ( !scene )
|
|
return;
|
|
|
|
RECT rcClient = m_rcBounds;;
|
|
//drawHelper.GetClientRect( rcClient );
|
|
|
|
// Iterate relative tags
|
|
for ( int i = 0; i < scene->GetNumActors(); i++ )
|
|
{
|
|
CChoreoActor *a = scene->GetActor( i );
|
|
if ( !a )
|
|
continue;
|
|
|
|
for ( int j = 0; j < a->GetNumChannels(); j++ )
|
|
{
|
|
CChoreoChannel *c = a->GetChannel( j );
|
|
if ( !c )
|
|
continue;
|
|
|
|
for ( int k = 0 ; k < c->GetNumEvents(); k++ )
|
|
{
|
|
CChoreoEvent *e = c->GetEvent( k );
|
|
if ( !e )
|
|
continue;
|
|
|
|
// add each tag to combo box
|
|
for ( int t = 0; t < e->GetNumRelativeTags(); t++ )
|
|
{
|
|
CEventRelativeTag *tag = e->GetRelativeTag( t );
|
|
if ( !tag )
|
|
continue;
|
|
|
|
//SendMessage( control, CB_ADDSTRING, 0, (LPARAM)va( "\"%s\" \"%s\"", tag->GetName(), e->GetParameters() ) );
|
|
bool clipped = false;
|
|
int tagx = GetMouseForTime( tag->GetStartTime() - event->GetStartTime(), &clipped );
|
|
if ( clipped )
|
|
continue;
|
|
|
|
drawHelper.DrawColoredLine( RGB( 180, 180, 220 ), PS_SOLID, 1, tagx, rcClient.top, tagx, rcClient.bottom );
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
for ( int t = 0; t < event->GetNumTimingTags(); t++ )
|
|
{
|
|
CFlexTimingTag *tag = event->GetTimingTag( t );
|
|
if ( !tag )
|
|
continue;
|
|
|
|
bool clipped = false;
|
|
int tagx = GetMouseForTime( tag->GetStartTime() - event->GetStartTime(), &clipped );
|
|
if ( clipped )
|
|
continue;
|
|
|
|
// Draw relative tag marker
|
|
drawHelper.DrawColoredLine( RGB( 220, 180, 180 ), PS_SOLID, 1, tagx, rcClient.top, tagx, rcClient.bottom );
|
|
}
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose:
|
|
// Input : *exp -
|
|
// flexnum -
|
|
//-----------------------------------------------------------------------------
|
|
void TimelineItem::SetExpressionInfo( CFlexAnimationTrack *track, int flexnum )
|
|
{
|
|
m_szTrackName[ 0 ] = 0;
|
|
if ( track )
|
|
{
|
|
V_strcpy_safe( m_szTrackName, track->GetFlexControllerName() );
|
|
SetActive( track->IsTrackActive() );
|
|
}
|
|
|
|
m_nFlexNum = flexnum;
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose:
|
|
//-----------------------------------------------------------------------------
|
|
void TimelineItem::Copy( void )
|
|
{
|
|
if ( !g_pExpressionTool )
|
|
return;
|
|
|
|
CFlexAnimationTrack *track = GetSafeTrack();
|
|
if ( !track )
|
|
return;
|
|
|
|
g_pExpressionTool->Copy( track );
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose:
|
|
//-----------------------------------------------------------------------------
|
|
void TimelineItem::Paste( void )
|
|
{
|
|
if ( !g_pExpressionTool )
|
|
return;
|
|
|
|
if ( !g_pExpressionTool->HasCopyData() )
|
|
return;
|
|
|
|
CFlexAnimationTrack *track = GetSafeTrack();
|
|
if ( !track )
|
|
return;
|
|
|
|
g_pExpressionTool->Paste( track );
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose:
|
|
//-----------------------------------------------------------------------------
|
|
void TimelineItem::Clear( bool preserveundo )
|
|
{
|
|
CFlexAnimationTrack *track = GetSafeTrack();
|
|
if ( !track )
|
|
return;
|
|
|
|
if ( preserveundo )
|
|
{
|
|
PreDataChanged( "Clear" );
|
|
}
|
|
|
|
track->Clear();
|
|
|
|
if ( preserveundo )
|
|
{
|
|
PostDataChanged( "Clear" );
|
|
}
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose:
|
|
// Input : state -
|
|
//-----------------------------------------------------------------------------
|
|
void TimelineItem::SetCollapsed( bool state )
|
|
{
|
|
m_bCollapsed = state;
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose:
|
|
// Output : Returns true on success, false on failure.
|
|
//-----------------------------------------------------------------------------
|
|
bool TimelineItem::IsCollapsed( void ) const
|
|
{
|
|
return m_bCollapsed;
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose:
|
|
// Output : int
|
|
//-----------------------------------------------------------------------------
|
|
int TimelineItem::GetHeight( void )
|
|
{
|
|
return ( IsCollapsed() ? 12 : m_nCurrentHeight );
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose:
|
|
// Input : state -
|
|
//-----------------------------------------------------------------------------
|
|
void TimelineItem::SetActive( bool state )
|
|
{
|
|
CFlexAnimationTrack *track = GetSafeTrack();
|
|
if ( !track )
|
|
return;
|
|
|
|
track->SetTrackActive( state );
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose:
|
|
// Output : Returns true on success, false on failure.
|
|
//-----------------------------------------------------------------------------
|
|
bool TimelineItem::IsActive( void )
|
|
{
|
|
CFlexAnimationTrack *track = GetSafeTrack();
|
|
if ( !track )
|
|
return false;
|
|
|
|
return track->IsTrackActive();
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose:
|
|
// Output : Returns true on success, false on failure.
|
|
//-----------------------------------------------------------------------------
|
|
bool TimelineItem::IsValid( void )
|
|
{
|
|
CFlexAnimationTrack *track = GetSafeTrack();
|
|
if ( !track )
|
|
return false;
|
|
|
|
if ( track->GetNumSamples( 0 ) > 0 )
|
|
return true;
|
|
|
|
return false;
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose:
|
|
// Output : CFlexAnimationTrack
|
|
//-----------------------------------------------------------------------------
|
|
CFlexAnimationTrack *TimelineItem::GetSafeTrack( void )
|
|
{
|
|
if ( !g_pExpressionTool )
|
|
return NULL;
|
|
|
|
CChoreoEvent *ev = g_pExpressionTool->GetSafeEvent();
|
|
if ( !ev )
|
|
return NULL;
|
|
|
|
// Find track by name
|
|
for ( int i = 0; i < ev->GetNumFlexAnimationTracks() ; i++ )
|
|
{
|
|
CFlexAnimationTrack *track = ev->GetFlexAnimationTrack( i );
|
|
if ( track && !stricmp( track->GetFlexControllerName(), m_szTrackName ) )
|
|
{
|
|
return track;
|
|
}
|
|
}
|
|
|
|
return NULL;
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose:
|
|
// Input : type -
|
|
//-----------------------------------------------------------------------------
|
|
void TimelineItem::SetEditType( int type )
|
|
{
|
|
Assert( type == 0 || type == 1 );
|
|
|
|
CFlexAnimationTrack *track = GetSafeTrack();
|
|
if ( !track || !track->IsComboType() )
|
|
{
|
|
type = 0;
|
|
}
|
|
|
|
m_nEditType = type;
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose:
|
|
// Output : int
|
|
//-----------------------------------------------------------------------------
|
|
int TimelineItem::GetEditType( void )
|
|
{
|
|
return m_nEditType;
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose:
|
|
//-----------------------------------------------------------------------------
|
|
void TimelineItem::SelectPoints( void )
|
|
{
|
|
RECT rcSelection;
|
|
|
|
rcSelection.left = m_nStartX < m_nLastX ? m_nStartX : m_nLastX;
|
|
rcSelection.right = m_nStartX < m_nLastX ? m_nLastX : m_nStartX;
|
|
|
|
rcSelection.top = m_nStartY < m_nLastY ? m_nStartY : m_nLastY;
|
|
rcSelection.bottom = m_nStartY < m_nLastY ? m_nLastY : m_nStartY;
|
|
|
|
int selW = rcSelection.right - rcSelection.left;
|
|
int selH = rcSelection.bottom - rcSelection.top;
|
|
|
|
float tolerance = FP_TL_SELECTION_RECTANGLE_TOLERANCE;
|
|
// If they are just clicking and releasing in one spot, capture any items w/in a larger tolerance
|
|
if ( selW <= 2 && selH <= 2 )
|
|
{
|
|
tolerance = FP_TL_SELECTION_TOLERANCE;
|
|
|
|
CExpressionSample *sample = GetSampleUnderMouse( rcSelection.left + selW * 0.5f, rcSelection.top + selH * 0.5f );
|
|
if ( sample )
|
|
{
|
|
sample->selected = true;
|
|
return;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
InflateRect( &rcSelection, 3, 3 );
|
|
}
|
|
|
|
int width = m_rcBounds.right - m_rcBounds.left;
|
|
int height = m_rcBounds.bottom - m_rcBounds.top;
|
|
|
|
CFlexAnimationTrack *track = GetSafeTrack();
|
|
if ( !track || !width || !height )
|
|
return;
|
|
|
|
CChoreoEvent *e = track->GetEvent();
|
|
Assert( e );
|
|
if ( !e )
|
|
return;
|
|
|
|
float duration = e->GetDuration();
|
|
|
|
float fleft = (float)GetTimeForMouse( rcSelection.left + m_rcBounds.left );
|
|
float fright = (float)GetTimeForMouse( rcSelection.right + m_rcBounds.left );
|
|
|
|
//fleft *= duration;
|
|
//fright *= duration;
|
|
|
|
float ftop = (float)rcSelection.top / (float)height;
|
|
float fbottom = (float)rcSelection.bottom / (float)height;
|
|
|
|
fleft = clamp( fleft, 0.0f, duration );
|
|
fright = clamp( fright, 0.0f, duration );
|
|
ftop = clamp( ftop, 0.0f, 1.0f );
|
|
fbottom = clamp( fbottom, 0.0f, 1.0f );
|
|
|
|
float timestepperpixel = 1.0f / g_pExpressionTool->GetPixelsPerSecond();
|
|
float yfracstepperpixel = 1.0f / (float)height;
|
|
|
|
float epsx = tolerance*timestepperpixel;
|
|
float epsy = tolerance*yfracstepperpixel;
|
|
|
|
for ( int i = 0; i < track->GetNumSamples( m_nEditType ); i++ )
|
|
{
|
|
CExpressionSample *sample = track->GetSample( i, m_nEditType );
|
|
|
|
if ( sample->time + epsx < fleft )
|
|
continue;
|
|
|
|
if ( sample->time - epsx > fright )
|
|
continue;
|
|
|
|
if ( (1.0f - sample->value ) + epsy < ftop )
|
|
continue;
|
|
|
|
if ( (1.0f - sample->value ) - epsy > fbottom )
|
|
continue;
|
|
|
|
sample->selected = true;
|
|
}
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose:
|
|
// Input : *undodescription -
|
|
//-----------------------------------------------------------------------------
|
|
void TimelineItem::PreDataChanged( char const *undodescription )
|
|
{
|
|
if ( m_nUndoSetup == 0 )
|
|
{
|
|
g_pChoreoView->SetDirty( true );
|
|
g_pChoreoView->PushUndo( undodescription );
|
|
}
|
|
++m_nUndoSetup;
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose:
|
|
// Input : *redodescription -
|
|
//-----------------------------------------------------------------------------
|
|
void TimelineItem::PostDataChanged( char const *redodescription )
|
|
{
|
|
--m_nUndoSetup;
|
|
if ( m_nUndoSetup == 0 )
|
|
{
|
|
g_pChoreoView->PushRedo( redodescription );
|
|
g_pExpressionTool->InvalidateLayout();
|
|
}
|
|
}
|
|
|
|
void TimelineItem::SetBounds( const RECT& rect )
|
|
{
|
|
m_rcBounds = rect;
|
|
}
|
|
|
|
void TimelineItem::GetBounds( RECT& rect )
|
|
{
|
|
rect = m_rcBounds;
|
|
}
|
|
|
|
void TimelineItem::SetVisible( bool vis )
|
|
{
|
|
m_bVisible = vis;
|
|
}
|
|
|
|
bool TimelineItem::GetVisible( void ) const
|
|
{
|
|
return m_bVisible;
|
|
}
|
|
|
|
int TimelineItem::GetNumSelected( void )
|
|
{
|
|
return m_nNumSelected;
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose:
|
|
//-----------------------------------------------------------------------------
|
|
void TimelineItem::SnapAll()
|
|
{
|
|
CFlexAnimationTrack *track = GetSafeTrack();
|
|
if ( !track )
|
|
return;
|
|
|
|
for ( int t = 0; t < 2; t++ )
|
|
{
|
|
for ( int i = 0; i < track->GetNumSamples( t ); i++ )
|
|
{
|
|
CExpressionSample *sample = track->GetSample( i, t );
|
|
sample->time = FacePoser_SnapTime( sample->time );
|
|
}
|
|
}
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose:
|
|
//-----------------------------------------------------------------------------
|
|
void TimelineItem::SnapSelected()
|
|
{
|
|
CFlexAnimationTrack *track = GetSafeTrack();
|
|
if ( !track )
|
|
return;
|
|
|
|
for ( int t = 0; t < 2; t++ )
|
|
{
|
|
for ( int i = 0; i < track->GetNumSamples( t ); i++ )
|
|
{
|
|
CExpressionSample *sample = track->GetSample( i, t );
|
|
if ( !sample->selected )
|
|
continue;
|
|
|
|
sample->time = FacePoser_SnapTime( sample->time );
|
|
}
|
|
}
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose:
|
|
// Input : start -
|
|
// end -
|
|
//-----------------------------------------------------------------------------
|
|
void TimelineItem::DeletePoints( float start, float end )
|
|
{
|
|
CFlexAnimationTrack *track = GetSafeTrack();
|
|
if ( !track )
|
|
return;
|
|
|
|
for ( int t = 0; t < 2; t++ )
|
|
{
|
|
int num = track->GetNumSamples( t );
|
|
for ( int i = num - 1; i >= 0 ; i-- )
|
|
{
|
|
CExpressionSample *sample = track->GetSample( i, t );
|
|
if ( sample->time < start || sample->time > end )
|
|
continue;
|
|
|
|
track->RemoveSample( i, t );
|
|
}
|
|
}
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose:
|
|
//-----------------------------------------------------------------------------
|
|
void TimelineItem::OnDoubleClicked()
|
|
{
|
|
// Disabled for now by request of BillF
|
|
CFlexAnimationTrack *track = GetSafeTrack();
|
|
if ( !track )
|
|
return;
|
|
|
|
SetCollapsed( !IsCollapsed() );
|
|
g_pExpressionTool->LayoutItems( true );
|
|
}
|
|
|
|
void TimelineItem::DrawEventEnd( CChoreoWidgetDrawHelper& drawHelper )
|
|
{
|
|
CFlexAnimationTrack *track = GetSafeTrack();
|
|
if ( !track )
|
|
return;
|
|
|
|
CChoreoEvent *e = track->GetEvent();
|
|
if ( !e )
|
|
return;
|
|
|
|
float duration = e->GetDuration();
|
|
if ( !duration )
|
|
return;
|
|
|
|
int leftx = GetMouseForTime( duration );
|
|
if ( leftx > m_rcBounds.right )
|
|
return;
|
|
|
|
drawHelper.DrawColoredLine(
|
|
COLOR_CHOREO_ENDTIME, PS_SOLID, 1,
|
|
leftx, m_rcBounds.top, leftx, m_rcBounds.bottom );
|
|
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose:
|
|
// Input : helper -
|
|
// handleRect -
|
|
//-----------------------------------------------------------------------------
|
|
void TimelineItem::DrawGrowHandle( CChoreoWidgetDrawHelper& helper, RECT& handleRect )
|
|
{
|
|
Assert(CanHaveGrowHandle());
|
|
|
|
RECT useRect = handleRect;
|
|
helper.OffsetSubRect( useRect );
|
|
|
|
POINT region[4];
|
|
int cPoints = 4;
|
|
|
|
region[ 0 ].x = useRect.left + GROW_HANDLE_INSETPIXELS;
|
|
region[ 0 ].y = useRect.top;
|
|
|
|
region[ 1 ].x = useRect.right - GROW_HANDLE_INSETPIXELS;
|
|
region[ 1 ].y = useRect.top;
|
|
|
|
region[ 2 ].x = useRect.right;
|
|
region[ 2 ].y = useRect.bottom;
|
|
|
|
region[ 3 ].x = useRect.left;
|
|
region[ 3 ].y = useRect.bottom;
|
|
|
|
HDC dc = helper.GrabDC();
|
|
|
|
HRGN rgn = CreatePolygonRgn( region, cPoints, ALTERNATE );
|
|
|
|
int oldPF = SetPolyFillMode( dc, ALTERNATE );
|
|
|
|
HBRUSH brBg = CreateSolidBrush( RGB( 150, 150, 150 ) );
|
|
HBRUSH brBorder = CreateSolidBrush( RGB( 200, 200, 200 ) );
|
|
|
|
FillRgn( dc, rgn, brBg );
|
|
FrameRgn( dc, rgn, brBorder, 1, 1 );
|
|
|
|
SetPolyFillMode( dc, oldPF );
|
|
|
|
DeleteObject( rgn );
|
|
|
|
DeleteObject( brBg );
|
|
DeleteObject( brBorder );
|
|
|
|
// draw a line in the middle
|
|
int midy = ( handleRect.bottom + handleRect.top ) * 0.5f;
|
|
int lineinset = GROW_HANDLE_INSETPIXELS *1.5;
|
|
|
|
helper.DrawColoredLine( RGB( 63, 63, 63 ), PS_SOLID, 1,
|
|
handleRect.left + lineinset, midy,
|
|
handleRect.right - lineinset, midy );
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose:
|
|
// Input : rc -
|
|
//-----------------------------------------------------------------------------
|
|
void TimelineItem::GetGrowHandleRect( RECT& rc )
|
|
{
|
|
rc = m_rcBounds;
|
|
rc.bottom -= 1;
|
|
rc.top = rc.bottom - GROW_HANDLE_HEIGHT;
|
|
rc.left = ( rc.right + rc.left ) / 2 - GROW_HANDLE_WIDTH / 2;
|
|
rc.right = rc.left + GROW_HANDLE_WIDTH;
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose:
|
|
// Output : Returns true on success, false on failure.
|
|
//-----------------------------------------------------------------------------
|
|
bool TimelineItem::CanHaveGrowHandle()
|
|
{
|
|
if ( IsCollapsed() )
|
|
return false;
|
|
|
|
if ( !g_pExpressionTool->IsFocusItem( this ) )
|
|
return false;
|
|
|
|
return true;
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose:
|
|
// Input : x -
|
|
// y -
|
|
// Output : Returns true on success, false on failure.
|
|
//-----------------------------------------------------------------------------
|
|
bool TimelineItem::IsMouseOverGrowHandle( int x, int y)
|
|
{
|
|
if ( !CanHaveGrowHandle() )
|
|
return false;
|
|
|
|
RECT rcGrowHandle;
|
|
GetGrowHandleRect( rcGrowHandle );
|
|
|
|
POINT pt;
|
|
pt.x = x + m_rcBounds.left;
|
|
pt.y = y + m_rcBounds.top;
|
|
|
|
return PtInRect( &rcGrowHandle, pt ) ? true : false;
|
|
}
|
|
|
|
void TimelineItem::DrawGrowRect()
|
|
{
|
|
RECT rcFocus = m_rcBounds;
|
|
rcFocus.bottom = m_rcBounds.top + m_nLastY;
|
|
OffsetRect( &rcFocus, -m_rcBounds.left, -m_rcBounds.top );
|
|
|
|
POINT offset;
|
|
offset.x = m_rcBounds.left;
|
|
offset.y = m_rcBounds.top;
|
|
ClientToScreen( (HWND)m_pWorkspace->getHandle(), &offset );
|
|
OffsetRect( &rcFocus, offset.x, offset.y );
|
|
|
|
HDC dc = GetDC( NULL );
|
|
|
|
::DrawFocusRect( dc, &rcFocus );
|
|
|
|
ReleaseDC( NULL, dc );
|
|
}
|
|
|
|
void TimelineItem::GetWorkList( bool reflect, CUtlVector< TimelineItem * >& list )
|
|
{
|
|
if ( !reflect )
|
|
{
|
|
list.AddToTail( this );
|
|
}
|
|
else
|
|
{
|
|
g_pExpressionTool->GetTimelineItems( list );
|
|
}
|
|
}
|