1212 lines
28 KiB
C++
1212 lines
28 KiB
C++
//========= Copyright Valve Corporation, All rights reserved. ============//
|
|
//
|
|
// Purpose:
|
|
//
|
|
// $NoKeywords: $
|
|
//=============================================================================//
|
|
#include "hlfaceposer.h"
|
|
#include <windows.h>
|
|
#include <stdio.h>
|
|
#include <mxtk/mxWindow.h>
|
|
#include <mxtk/mxScrollBar.h>
|
|
#include "mxexpressiontray.h"
|
|
#include "expressions.h"
|
|
#include "expclass.h"
|
|
#include "ControlPanel.h"
|
|
#include "FlexPanel.h"
|
|
#include <mxtk/mxPopupMenu.h>
|
|
#include "ChoreoView.h"
|
|
#include "StudioModel.h"
|
|
#include "ExpressionProperties.h"
|
|
#include "InputProperties.h"
|
|
#include "ViewerSettings.h"
|
|
#include "mxExpressionTab.h"
|
|
#include "choreowidgetdrawhelper.h"
|
|
#include "ExpressionTool.h"
|
|
#include "faceposer_models.h"
|
|
#include "tier0/icommandline.h"
|
|
#include "filesystem.h"
|
|
|
|
#define MAX_THUMBNAILSIZE 256
|
|
#define MIN_THUMBNAILSIZE 64
|
|
#define THUMBNAIL_SIZE_STEP 4
|
|
#define DEFAULT_THUMBNAIL_SIZE 128
|
|
#define TOP_GAP 45
|
|
|
|
mxExpressionTray *g_pExpressionTrayTool = 0;
|
|
|
|
mxExpressionTray::mxExpressionTray( mxWindow *parent, int id /*=0*/ )
|
|
: IFacePoserToolWindow( "ExpressionTrayTool", "Expressions" ), mxWindow( parent, 0, 0, 0, 0, "ExpressionTrayTool", id )
|
|
{
|
|
setId( id );
|
|
|
|
m_nTopOffset = 0;
|
|
slScrollbar = new mxScrollbar( this, 0, 0, 18, 100, IDC_TRAYSCROLL, mxScrollbar::Vertical );
|
|
|
|
m_nLastNumExpressions = -1;
|
|
|
|
m_nGranularity = 10;
|
|
|
|
m_nPrevCell = -1;
|
|
m_nCurCell = -1;
|
|
|
|
m_nClickedCell = -1;
|
|
|
|
m_nButtonSquare = 16;
|
|
|
|
m_nGap = 4;
|
|
m_nDescriptionHeight = 34;
|
|
m_nSnapshotWidth = g_viewerSettings.thumbnailsize;
|
|
m_nSnapshotWidth = max( MIN_THUMBNAILSIZE, m_nSnapshotWidth );
|
|
m_nSnapshotWidth = min( MAX_THUMBNAILSIZE, m_nSnapshotWidth );
|
|
|
|
g_viewerSettings.thumbnailsize = m_nSnapshotWidth;
|
|
|
|
m_nSnapshotHeight = m_nSnapshotWidth + m_nDescriptionHeight;
|
|
|
|
m_pButtons = NULL;
|
|
|
|
m_nPreviousExpressionCount = -1;
|
|
|
|
m_bDragging = false;
|
|
m_nDragCell = -1;
|
|
|
|
CreateButtons();
|
|
|
|
g_pExpressionClass = new mxExpressionTab( this, 5, 5, 500, 20, IDC_EXPRESSIONCLASS );
|
|
|
|
m_pABButton = new mxButton( this, 520, 8, 50, 18, "A/B", IDC_AB );
|
|
m_pThumbnailIncreaseButton = new mxButton( this, 0, 0, 18, 18, "+", IDC_THUMBNAIL_INCREASE );
|
|
m_pThumbnailDecreaseButton = new mxButton( this, 0, 0, 18, 18, "-", IDC_THUMBNAIL_DECREASE );
|
|
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose:
|
|
// Output : mxExpressionTray::~mxExpressionTray
|
|
//-----------------------------------------------------------------------------
|
|
mxExpressionTray::~mxExpressionTray ( void )
|
|
{
|
|
DeleteAllButtons();
|
|
g_pExpressionTrayTool = NULL;
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose:
|
|
// Input : cellsize -
|
|
//-----------------------------------------------------------------------------
|
|
void mxExpressionTray::SetCellSize( int cellsize )
|
|
{
|
|
m_nSnapshotWidth = cellsize;
|
|
m_nSnapshotHeight = cellsize + m_nDescriptionHeight;
|
|
|
|
DeleteAllButtons();
|
|
CreateButtons();
|
|
|
|
redraw();
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose:
|
|
//-----------------------------------------------------------------------------
|
|
void mxExpressionTray::Deselect( void )
|
|
{
|
|
CExpClass *active = expressions->GetActiveClass();
|
|
if ( active )
|
|
{
|
|
for ( int i = 0 ; i < active->GetNumExpressions(); i++ )
|
|
{
|
|
CExpression *exp = active->GetExpression( i );
|
|
if ( exp )
|
|
{
|
|
exp->SetSelected( false );
|
|
}
|
|
}
|
|
}
|
|
|
|
m_nCurCell = m_nPrevCell = -1;
|
|
redraw();
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose:
|
|
// Input : exp -
|
|
//-----------------------------------------------------------------------------
|
|
void mxExpressionTray::Select( int exp, bool deselect /*=true*/ )
|
|
{
|
|
int oldcell = m_nCurCell;
|
|
|
|
if ( deselect )
|
|
{
|
|
Deselect();
|
|
}
|
|
|
|
m_nPrevCell = oldcell;
|
|
m_nCurCell = exp;
|
|
|
|
if ( m_nCurCell >= 0 )
|
|
{
|
|
CExpClass *active = expressions->GetActiveClass();
|
|
if ( active )
|
|
{
|
|
CExpression *exp = active->GetExpression( m_nCurCell );
|
|
if ( exp )
|
|
{
|
|
exp->SetSelected( true );
|
|
}
|
|
}
|
|
}
|
|
|
|
redraw();
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose:
|
|
// Input : *btn -
|
|
//-----------------------------------------------------------------------------
|
|
void mxExpressionTray::AddButton( const char *name, const char *tooltip, const char *bitmap, ETMEMBERFUNC pfnCallback,
|
|
bool active, int x, int y, int w, int h )
|
|
{
|
|
mxETButton *btn = new mxETButton;
|
|
strcpy( btn->m_szName, name );
|
|
strcpy( btn->m_szToolTip, tooltip );
|
|
btn->m_bActive = active;
|
|
btn->m_rc.left = x;
|
|
btn->m_rc.top = y;
|
|
btn->m_rc.right = x + w;
|
|
btn->m_rc.bottom = y + h;
|
|
|
|
btn->m_pImage = new mxbitmapdata_t;
|
|
Assert( btn->m_pImage );
|
|
btn->m_pImage->valid = false;
|
|
LoadBitmapFromFile( bitmap, *btn->m_pImage );
|
|
|
|
btn->m_fnCallback = pfnCallback;
|
|
|
|
btn->next = m_pButtons;
|
|
m_pButtons = btn;
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose:
|
|
//-----------------------------------------------------------------------------
|
|
void mxExpressionTray::CreateButtons( void )
|
|
{
|
|
int x = m_nSnapshotWidth - 2 * ( m_nButtonSquare + 4 );
|
|
int y = 4;
|
|
|
|
AddButton( "undo", "Undo", "gfx/hlfaceposer/undo.bmp", &mxExpressionTray::ET_Undo, true, x, y, m_nButtonSquare, m_nButtonSquare );
|
|
|
|
x += ( m_nButtonSquare + 4 );
|
|
|
|
AddButton( "redo", "Redo", "gfx/hlfaceposer/redo.bmp", &mxExpressionTray::ET_Redo, true, x, y, m_nButtonSquare, m_nButtonSquare );
|
|
}
|
|
|
|
void mxExpressionTray::ActivateButton( const char *name, bool active )
|
|
{
|
|
mxETButton *btn = FindButton( name );
|
|
if ( !name )
|
|
return;
|
|
|
|
btn->m_bActive = active;
|
|
}
|
|
|
|
mxExpressionTray::mxETButton *mxExpressionTray::FindButton( const char *name )
|
|
{
|
|
mxETButton *p = m_pButtons;
|
|
while ( p )
|
|
{
|
|
if ( !stricmp( p->m_szName, name ) )
|
|
return p;
|
|
p = p->next;
|
|
}
|
|
return NULL;
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose:
|
|
//-----------------------------------------------------------------------------
|
|
void mxExpressionTray::DeleteAllButtons( void )
|
|
{
|
|
mxETButton *p = m_pButtons, *n;
|
|
while ( p )
|
|
{
|
|
n = p->next;
|
|
delete p->m_pImage;
|
|
delete p;
|
|
p = n;
|
|
}
|
|
m_pButtons = NULL;
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose:
|
|
// Input : x -
|
|
// y -
|
|
// Output : mxExpressionTray::mxETButton
|
|
//-----------------------------------------------------------------------------
|
|
mxExpressionTray::mxETButton *mxExpressionTray::GetItemUnderCursor( int x, int y )
|
|
{
|
|
// Convert to cell space
|
|
int cell = GetCellUnderPosition( x, y );
|
|
if ( cell == -1 )
|
|
{
|
|
return NULL;
|
|
}
|
|
|
|
// Cell is off screen?
|
|
int cx, cy, cw, ch;
|
|
if ( !ComputeRect( cell, cx, cy, cw, ch ) )
|
|
{
|
|
return NULL;
|
|
}
|
|
|
|
|
|
mxETButton *p = m_pButtons;
|
|
while ( p )
|
|
{
|
|
if ( p->m_bActive &&
|
|
x >= cx &&
|
|
x <= cx + cw &&
|
|
y >= cy &&
|
|
y <= cy + ch )
|
|
{
|
|
// In-side cell
|
|
int cellx = x - cx;
|
|
int celly = y - cy;
|
|
|
|
if ( cellx >= p->m_rc.left &&
|
|
cellx <= p->m_rc.right &&
|
|
celly >= p->m_rc.top &&
|
|
celly <= p->m_rc.bottom )
|
|
{
|
|
return p;
|
|
}
|
|
}
|
|
p = p->next;
|
|
}
|
|
|
|
return NULL;
|
|
}
|
|
|
|
void mxExpressionTray::DrawButton( CChoreoWidgetDrawHelper& helper, int cell, mxETButton *btn )
|
|
{
|
|
if ( !btn || !btn->m_pImage || !btn->m_pImage->valid )
|
|
return;
|
|
|
|
if ( !btn->m_bActive )
|
|
return;
|
|
|
|
int x, y, w, h;
|
|
if ( !ComputeRect( cell, x, y, w, h ) )
|
|
return;
|
|
|
|
x += btn->m_rc.left;
|
|
y += btn->m_rc.top;
|
|
w = btn->m_rc.right - btn->m_rc.left;
|
|
h = btn->m_rc.bottom - btn->m_rc.top;
|
|
|
|
HDC dc = helper.GrabDC();
|
|
|
|
DrawBitmapToDC( dc, x, y, w, h, *btn->m_pImage );
|
|
helper.DrawOutlinedRect( RGB( 170, 170, 170 ), PS_SOLID, 1, x, y, x + w, y + h );
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose:
|
|
// Output : int
|
|
//-----------------------------------------------------------------------------
|
|
int mxExpressionTray::ComputePixelsNeeded( void )
|
|
{
|
|
CExpClass *active = expressions->GetActiveClass();
|
|
if ( !active )
|
|
return 100;
|
|
|
|
// Remove scroll bar
|
|
int w = this->w2() - 16;
|
|
|
|
int colsperrow;
|
|
|
|
colsperrow = ( w - m_nGap ) / ( m_nSnapshotWidth + m_nGap );
|
|
// At least one
|
|
colsperrow = max( 1, colsperrow );
|
|
|
|
int rowsneeded = ( ( active->GetNumExpressions() + colsperrow - 1 ) / colsperrow );
|
|
return rowsneeded * ( m_nSnapshotHeight + m_nGap ) + m_nGap + TOP_GAP + GetCaptionHeight();
|
|
}
|
|
|
|
bool mxExpressionTray::ComputeRect( int cell, int& rcx, int& rcy, int& rcw, int& rch )
|
|
{
|
|
// Remove scroll bar
|
|
int w = this->w2() - 16;
|
|
|
|
int colsperrow;
|
|
|
|
colsperrow = ( w - m_nGap ) / ( m_nSnapshotWidth + m_nGap );
|
|
// At least one
|
|
colsperrow = max( 1, colsperrow );
|
|
|
|
int row, col;
|
|
|
|
row = cell / colsperrow;
|
|
col = cell % colsperrow;
|
|
|
|
// don't allow partial columns
|
|
|
|
rcx = m_nGap + col * ( m_nSnapshotWidth + m_nGap );
|
|
rcy = GetCaptionHeight() + TOP_GAP + ( -m_nTopOffset * m_nGranularity ) + m_nGap + row * ( m_nSnapshotHeight + m_nGap );
|
|
|
|
// Starts off screen
|
|
if ( rcx < 0 )
|
|
return false;
|
|
|
|
// Ends off screen
|
|
if ( rcx + m_nSnapshotWidth + m_nGap > this->w2() )
|
|
return false;
|
|
|
|
// Allow partial in y direction
|
|
if ( rcy > this->h2() )
|
|
return false;
|
|
|
|
if ( rcy + m_nSnapshotHeight + m_nGap < 0 )
|
|
return false;
|
|
|
|
// Some portion is onscreen
|
|
rcw = m_nSnapshotWidth;
|
|
rch = m_nSnapshotHeight;
|
|
return true;
|
|
}
|
|
|
|
void mxExpressionTray::DrawExpressionFocusRect( CChoreoWidgetDrawHelper& helper, int x, int y, int w, int h, COLORREF clr )
|
|
{
|
|
helper.DrawOutlinedRect( clr, PS_SOLID, 4, x, y, x + w, y + h );
|
|
}
|
|
|
|
void mxExpressionTray::DrawExpressionDescription( CChoreoWidgetDrawHelper& helper, int x, int y, int w, int h, const char *expressionname, const char *description )
|
|
{
|
|
int textheight = 15;
|
|
|
|
RECT textRect;
|
|
textRect.left = x + 5;
|
|
textRect.top = y + h - 2 * textheight - 12;
|
|
textRect.right = x + w - 10;
|
|
textRect.bottom = y + h - 12;
|
|
|
|
helper.DrawColoredText( "Arial", 9, FW_NORMAL, RGB( 0, 0, 0 ), textRect, "%s", expressionname );
|
|
|
|
// DrawText( hdc, expressionname, strlen( expressionname ), &textRect, DT_NOPREFIX | DT_SINGLELINE | DT_LEFT | DT_VCENTER | DT_WORD_ELLIPSIS );
|
|
|
|
OffsetRect( &textRect, 0, textheight );
|
|
|
|
helper.DrawColoredText( "Arial", 9, FW_NORMAL, RGB( 63, 63, 63 ), textRect, "%s", description );
|
|
|
|
// DrawText( hdc, description, strlen( description ), &textRect, DT_NOPREFIX | DT_SINGLELINE | DT_LEFT | DT_VCENTER | DT_WORD_ELLIPSIS );
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose:
|
|
// Input : dc -
|
|
// current -
|
|
// rcx -
|
|
// rcy -
|
|
// rcw -
|
|
// rch -
|
|
//-----------------------------------------------------------------------------
|
|
void mxExpressionTray::DrawDirtyFlag( CChoreoWidgetDrawHelper& helper, CExpression *current, int rcx, int rcy, int rcw, int rch )
|
|
{
|
|
// Not dirty
|
|
if ( !current || ( !current->CanUndo() && !current->GetDirty() ) )
|
|
return;
|
|
|
|
int fontsize = 14;
|
|
|
|
RECT textRect;
|
|
textRect.left = rcx + 5;
|
|
textRect.right = rcx + rcw;
|
|
textRect.top = rcy + 5;
|
|
textRect.bottom = textRect.top + fontsize + 2;
|
|
|
|
helper.DrawColoredText( "Arial", fontsize, FW_NORMAL, RGB( 100, 240, 255 ), textRect, "*" );
|
|
}
|
|
|
|
bool mxExpressionTray::PaintBackground( void )
|
|
{
|
|
redraw();
|
|
return false;
|
|
}
|
|
|
|
void mxExpressionTray::DrawThumbNail( CExpClass *active, CExpression *current, CChoreoWidgetDrawHelper& helper, int rcx, int rcy, int rcw, int rch, int c, int selected, bool updateselection )
|
|
{
|
|
if ( !current )
|
|
return;
|
|
|
|
HDC dc = helper.GrabDC();
|
|
|
|
helper.DrawFilledRect( GetSysColor( COLOR_BTNFACE ), rcx, rcy, rcw + rcx, rch + rcy );
|
|
|
|
if ( current->m_Bitmap[ models->GetActiveModelIndex() ].valid )
|
|
{
|
|
DrawBitmapToDC( dc, rcx, rcy, rcw, rch - m_nDescriptionHeight, current->m_Bitmap[ models->GetActiveModelIndex() ] );
|
|
helper.DrawOutlinedRect( RGB( 127, 127, 127 ), PS_SOLID, 1, rcx, rcy, rcx + rcw, rcy + rch - m_nDescriptionHeight );
|
|
}
|
|
|
|
DrawDirtyFlag( helper, current, rcx, rcy, rcw, rch );
|
|
|
|
DrawExpressionDescription( helper, rcx, rcy, rcw, rch, current->name, current->description );
|
|
|
|
if ( c == selected )
|
|
{
|
|
DrawExpressionFocusRect( helper, rcx, rcy, rcw, rch - m_nDescriptionHeight, RGB( 255, 100, 63 ) );
|
|
|
|
if ( updateselection )
|
|
{
|
|
m_nPrevCell = -1;
|
|
m_nCurCell = c;
|
|
}
|
|
|
|
if ( current->CanUndo() || current->CanRedo() )
|
|
{
|
|
if ( current->CanUndo() )
|
|
{
|
|
DrawButton( helper, c, FindButton( "undo" ) );
|
|
}
|
|
|
|
if ( current->CanRedo() )
|
|
{
|
|
DrawButton( helper, c, FindButton( "redo" ) );
|
|
}
|
|
|
|
RECT rc;
|
|
rc.left = rcx + rcw - 2 * ( m_nButtonSquare + 4 );
|
|
rc.top = rcy + m_nButtonSquare + 6;
|
|
rc.right = rc.left + 2 * ( m_nButtonSquare + 4 );
|
|
rc.bottom = rc.top + 15;
|
|
|
|
helper.DrawColoredText( "Arial", 9, FW_NORMAL, RGB( 200, 200, 200 ), rc,
|
|
"%i/%i", current->UndoCurrent(), current->UndoLevels() );
|
|
}
|
|
|
|
}
|
|
else
|
|
{
|
|
if ( current->GetSelected() )
|
|
{
|
|
DrawExpressionFocusRect( helper, rcx, rcy, rcw, rch - m_nDescriptionHeight, RGB( 127, 127, 220 ) );
|
|
}
|
|
}
|
|
}
|
|
|
|
void mxExpressionTray::redraw()
|
|
{
|
|
if ( !ToolCanDraw() )
|
|
return;
|
|
|
|
bool updateSelection = false;
|
|
|
|
CExpClass *active = expressions->GetActiveClass();
|
|
if ( active && active->GetNumExpressions() != m_nPreviousExpressionCount )
|
|
{
|
|
m_nTopOffset = 0;
|
|
|
|
RepositionSlider();
|
|
m_nPreviousExpressionCount = active->GetNumExpressions();
|
|
}
|
|
|
|
CChoreoWidgetDrawHelper helper( this, GetSysColor( COLOR_BTNFACE ) );
|
|
HandleToolRedraw( helper );
|
|
|
|
int w, h;
|
|
w = w2();
|
|
h = h2();
|
|
|
|
if ( active )
|
|
{
|
|
RECT clipRect;
|
|
helper.GetClientRect( clipRect );
|
|
|
|
clipRect.top += TOP_GAP + GetCaptionHeight();
|
|
|
|
helper.StartClipping( clipRect );
|
|
|
|
if ( m_nLastNumExpressions != active->GetNumExpressions() )
|
|
{
|
|
m_nTopOffset = 0;
|
|
m_nLastNumExpressions = active->GetNumExpressions();
|
|
RepositionSlider();
|
|
updateSelection = true;
|
|
}
|
|
|
|
int selected = active->GetSelectedExpression();
|
|
|
|
int rcx, rcy, rcw, rch;
|
|
|
|
int c = 0;
|
|
while ( c < active->GetNumExpressions() )
|
|
{
|
|
if ( !ComputeRect( c, rcx, rcy, rcw, rch ) )
|
|
{
|
|
c++;
|
|
continue;
|
|
}
|
|
|
|
CExpression *current = active->GetExpression( c );
|
|
if ( !current )
|
|
break;
|
|
|
|
DrawThumbNail( active, current, helper, rcx, rcy, rcw, rch, c, selected, updateSelection );
|
|
|
|
c++;
|
|
}
|
|
|
|
helper.StopClipping();
|
|
|
|
}
|
|
else
|
|
{
|
|
|
|
RECT rc;
|
|
helper.GetClientRect( rc );
|
|
|
|
// Arial 36 normal
|
|
char sz[ 256 ];
|
|
sprintf( sz, "No expression file loaded" );
|
|
|
|
int pointsize = 18;
|
|
|
|
int textlen = helper.CalcTextWidth( "Arial", pointsize, FW_NORMAL, sz );
|
|
|
|
RECT rcText;
|
|
rcText.top = ( rc.bottom - rc.top ) / 2 - pointsize / 2;
|
|
rcText.bottom = rcText.top + pointsize + 10;
|
|
int fullw = rc.right - rc.left;
|
|
|
|
rcText.left = rc.left + ( fullw - textlen ) / 2;
|
|
rcText.right = rcText.left + textlen;
|
|
|
|
helper.DrawColoredText( "Arial", pointsize, FW_NORMAL, RGB( 80, 80, 80 ), rcText, sz );
|
|
}
|
|
|
|
|
|
// ValidateRect( (HWND)getHandle(), &rc );
|
|
}
|
|
|
|
int mxExpressionTray::GetCellUnderPosition( int x, int y )
|
|
{
|
|
CExpClass *active = expressions->GetActiveClass();
|
|
if ( !active )
|
|
return -1;
|
|
|
|
int rcx, rcy, rcw, rch;
|
|
int c = 0;
|
|
while ( c < active->GetNumExpressions() )
|
|
{
|
|
if ( !ComputeRect( c, rcx, rcy, rcw, rch ) )
|
|
{
|
|
c++;
|
|
continue;
|
|
}
|
|
|
|
if ( x >= rcx && x <= rcx + rcw &&
|
|
y >= rcy && y <= rcy + rch )
|
|
{
|
|
return c;
|
|
}
|
|
|
|
c++;
|
|
}
|
|
return -1;
|
|
}
|
|
|
|
void mxExpressionTray::RepositionSlider( void )
|
|
{
|
|
int trueh = h2() - GetCaptionHeight();
|
|
|
|
int heightpixels = trueh / m_nGranularity;
|
|
int rangepixels = ComputePixelsNeeded() / m_nGranularity;
|
|
|
|
if ( rangepixels < heightpixels )
|
|
{
|
|
m_nTopOffset = 0;
|
|
slScrollbar->setVisible( false );
|
|
}
|
|
else
|
|
{
|
|
slScrollbar->setVisible( true );
|
|
}
|
|
|
|
slScrollbar->setBounds( w2() - 16, GetCaptionHeight() + TOP_GAP, 16, trueh - TOP_GAP );
|
|
|
|
m_nTopOffset = max( 0, m_nTopOffset );
|
|
m_nTopOffset = min( rangepixels, m_nTopOffset );
|
|
|
|
slScrollbar->setRange( 0, rangepixels );
|
|
slScrollbar->setValue( m_nTopOffset );
|
|
slScrollbar->setPagesize( heightpixels );
|
|
}
|
|
|
|
void mxExpressionTray::AB( void )
|
|
{
|
|
if ( m_nPrevCell == -1 && m_nCurCell == -1 )
|
|
return;
|
|
|
|
CExpClass *active = expressions->GetActiveClass();
|
|
if ( !active )
|
|
return;
|
|
|
|
if ( m_nPrevCell >= 0 && m_nPrevCell < active->GetNumExpressions() )
|
|
{
|
|
active->SelectExpression( m_nPrevCell );
|
|
}
|
|
}
|
|
|
|
int mxExpressionTray::CountSelected( void )
|
|
{
|
|
CExpClass *active = expressions->GetActiveClass();
|
|
if ( !active )
|
|
return 0;
|
|
|
|
int c = 0;
|
|
for ( int i = 0; i < active->GetNumExpressions(); i++ )
|
|
{
|
|
CExpression *exp = active->GetExpression( i );
|
|
if ( !exp )
|
|
continue;
|
|
|
|
if ( exp->GetSelected() )
|
|
{
|
|
c++;
|
|
}
|
|
}
|
|
|
|
return c;
|
|
}
|
|
|
|
void mxExpressionTray::SetClickedCell( int cell )
|
|
{
|
|
m_nClickedCell = cell;
|
|
}
|
|
|
|
void mxExpressionTray::ShowRightClickMenu( int mx, int my )
|
|
{
|
|
CExpClass *active = expressions->GetActiveClass();
|
|
if ( !active )
|
|
return;
|
|
|
|
mxPopupMenu *pop = new mxPopupMenu();
|
|
Assert( pop );
|
|
|
|
CExpression *exp = NULL;
|
|
if ( m_nClickedCell != -1 )
|
|
{
|
|
exp = active->GetExpression( m_nClickedCell );
|
|
}
|
|
|
|
pop->add( "New Expression...", IDC_CONTEXT_NEWEXP );
|
|
if ( exp )
|
|
{
|
|
pop->addSeparator();
|
|
pop->add( va( "Edit '%s'...", exp->name ), IDC_CONTEXT_EDITEXP );
|
|
pop->add( va( "Save '%s'", exp->name ), IDC_CONTEXT_SAVEEXP );
|
|
|
|
if ( exp->CanUndo() || exp->CanRedo() )
|
|
{
|
|
pop->add( va( "Revert '%s'", exp->name ), IDC_CONTEXT_REVERT );
|
|
}
|
|
pop->addSeparator();
|
|
pop->add( va( "Delete '%s'", exp->name ), IDC_CONTEXT_DELETEXP );
|
|
pop->addSeparator();
|
|
pop->add( va( "Re-create thumbnail for '%s'", exp->name ), IDC_CONTEXT_CREATEBITMAP );
|
|
}
|
|
|
|
pop->popup( this, mx, my );
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose:
|
|
//-----------------------------------------------------------------------------
|
|
void mxExpressionTray::DrawFocusRect( void )
|
|
{
|
|
HDC dc = GetDC( NULL );
|
|
|
|
::DrawFocusRect( dc, &m_rcFocus );
|
|
|
|
ReleaseDC( NULL, dc );
|
|
}
|
|
|
|
static bool IsWindowOrChild( mxWindow *parent, HWND test )
|
|
{
|
|
HWND parentHwnd = (HWND)parent->getHandle();
|
|
if ( test == parentHwnd ||
|
|
IsChild( parentHwnd, test ) )
|
|
{
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
int mxExpressionTray::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 )
|
|
{
|
|
default:
|
|
iret = 0;
|
|
break;
|
|
case IDC_EXPRESSIONCLASS:
|
|
{
|
|
int index = g_pExpressionClass->getSelectedIndex();
|
|
if ( index >= 0 )
|
|
{
|
|
CExpClass *current = expressions->GetClass( index );
|
|
if ( current )
|
|
{
|
|
// Switch classname
|
|
expressions->ActivateExpressionClass( current );
|
|
current->SelectExpression( 0 );
|
|
}
|
|
}
|
|
}
|
|
break;
|
|
case IDC_CONTEXT_NEWEXP:
|
|
g_pFlexPanel->NewExpression();
|
|
break;
|
|
case IDC_CONTEXT_EDITEXP:
|
|
if ( m_nClickedCell != -1 )
|
|
{
|
|
g_pFlexPanel->EditExpression();
|
|
}
|
|
break;
|
|
case IDC_CONTEXT_REVERT:
|
|
if ( m_nClickedCell != -1 )
|
|
{
|
|
g_pFlexPanel->RevertExpression( m_nClickedCell );
|
|
}
|
|
break;
|
|
case IDC_CONTEXT_SAVEEXP:
|
|
if ( m_nClickedCell != -1 )
|
|
{
|
|
g_pFlexPanel->SaveExpression( m_nClickedCell );
|
|
}
|
|
break;
|
|
case IDC_CONTEXT_DELETEXP:
|
|
if ( m_nClickedCell != -1 )
|
|
{
|
|
g_pControlPanel->DeleteExpression( m_nClickedCell );
|
|
}
|
|
break;
|
|
case IDC_TRAYSCROLL:
|
|
{
|
|
if (event->modifiers == SB_THUMBTRACK)
|
|
{
|
|
int offset = event->height;
|
|
|
|
slScrollbar->setValue( offset );
|
|
|
|
m_nTopOffset = offset;
|
|
|
|
redraw();
|
|
}
|
|
else if ( event->modifiers == SB_PAGEUP )
|
|
{
|
|
int offset = slScrollbar->getValue();
|
|
|
|
offset -= m_nGranularity;
|
|
offset = max( offset, slScrollbar->getMinValue() );
|
|
|
|
slScrollbar->setValue( offset );
|
|
InvalidateRect( (HWND)slScrollbar->getHandle(), NULL, TRUE );
|
|
|
|
m_nTopOffset = offset;
|
|
|
|
redraw();
|
|
}
|
|
else if ( event->modifiers == SB_PAGEDOWN )
|
|
{
|
|
int offset = slScrollbar->getValue();
|
|
|
|
offset += m_nGranularity;
|
|
offset = min( offset, slScrollbar->getMaxValue() );
|
|
|
|
slScrollbar->setValue( offset );
|
|
InvalidateRect( (HWND)slScrollbar->getHandle(), NULL, TRUE );
|
|
|
|
m_nTopOffset = offset;
|
|
|
|
redraw();
|
|
}
|
|
}
|
|
break;
|
|
case IDC_AB:
|
|
{
|
|
AB();
|
|
}
|
|
break;
|
|
case IDC_THUMBNAIL_INCREASE:
|
|
{
|
|
ThumbnailIncrease();
|
|
}
|
|
break;
|
|
case IDC_THUMBNAIL_DECREASE:
|
|
{
|
|
ThumbnailDecrease();
|
|
}
|
|
break;
|
|
case IDC_CONTEXT_CREATEBITMAP:
|
|
{
|
|
if ( m_nClickedCell >= 0 )
|
|
{
|
|
CExpClass *active = expressions->GetActiveClass();
|
|
if ( active )
|
|
{
|
|
CExpression *exp = active->GetExpression( m_nClickedCell );
|
|
if ( exp )
|
|
{
|
|
active->SelectExpression( m_nClickedCell );
|
|
exp->CreateNewBitmap( models->GetActiveModelIndex() );
|
|
redraw();
|
|
}
|
|
}
|
|
}
|
|
}
|
|
break;
|
|
}
|
|
break;
|
|
}
|
|
case mxEvent::MouseDown:
|
|
{
|
|
if ( !( event->buttons & mxEvent::MouseRightButton ) )
|
|
{
|
|
// Figure out cell #
|
|
int cell = GetCellUnderPosition( event->x, event->y );
|
|
CExpClass *active = expressions->GetActiveClass();
|
|
if ( active )
|
|
{
|
|
|
|
if ( cell == m_nCurCell && cell >= 0 && cell < active->GetNumExpressions() )
|
|
{
|
|
mxETButton *btn = GetItemUnderCursor( event->x, event->y );
|
|
if ( btn && btn->m_fnCallback )
|
|
{
|
|
(this->*(btn->m_fnCallback))( cell );
|
|
return iret;
|
|
}
|
|
}
|
|
|
|
if ( cell >= 0 && cell < active->GetNumExpressions() )
|
|
{
|
|
active->SelectExpression( cell, event->modifiers & mxEvent::KeyShift ? false : true );
|
|
|
|
int cx, cy, cw, ch;
|
|
if ( ComputeRect( cell, cx, cy, cw, ch ) )
|
|
{
|
|
m_bDragging = true;
|
|
m_nDragCell = cell;
|
|
|
|
m_nXStart = (short)event->x;
|
|
m_nYStart = (short)event->y;
|
|
|
|
m_rcFocus.left = cx;
|
|
m_rcFocus.top = cy;
|
|
m_rcFocus.right = cx + cw;
|
|
m_rcFocus.bottom = cy + ch - m_nDescriptionHeight;
|
|
|
|
POINT pt;
|
|
pt.x = pt.y = 0;
|
|
ClientToScreen( (HWND)getHandle(), &pt );
|
|
|
|
OffsetRect( &m_rcFocus, pt.x, pt.y );
|
|
|
|
m_rcOrig = m_rcFocus;
|
|
|
|
DrawFocusRect();
|
|
}
|
|
}
|
|
else
|
|
{
|
|
Deselect();
|
|
active->DeselectExpression();
|
|
redraw();
|
|
}
|
|
}
|
|
}
|
|
iret = 1;
|
|
}
|
|
break;
|
|
case mxEvent::MouseDrag:
|
|
{
|
|
if ( m_bDragging )
|
|
{
|
|
// Draw drag line of some kind
|
|
DrawFocusRect();
|
|
|
|
// update pos
|
|
m_rcFocus = m_rcOrig;
|
|
OffsetRect( &m_rcFocus, ( (short)event->x - m_nXStart ),
|
|
( (short)event->y - m_nYStart ) );
|
|
|
|
DrawFocusRect();
|
|
}
|
|
iret = 1;
|
|
}
|
|
break;
|
|
case mxEvent::MouseUp:
|
|
{
|
|
iret = 1;
|
|
|
|
if ( event->buttons & mxEvent::MouseRightButton )
|
|
{
|
|
SetClickedCell( GetCellUnderPosition( (short)event->x, (short)event->y ) );
|
|
ShowRightClickMenu( (short)event->x, (short)event->y );
|
|
return iret;
|
|
}
|
|
|
|
int cell = GetCellUnderPosition( event->x, event->y );
|
|
CExpClass *active = expressions->GetActiveClass();
|
|
|
|
if ( m_bDragging )
|
|
{
|
|
DrawFocusRect();
|
|
m_bDragging = false;
|
|
// See if we let go on top of the choreo view
|
|
|
|
if ( active )
|
|
{
|
|
// Convert x, y to screen space
|
|
POINT pt;
|
|
pt.x = (short)event->x;
|
|
pt.y = (short)event->y;
|
|
ClientToScreen( (HWND)getHandle(), &pt );
|
|
|
|
HWND maybeTool = WindowFromPoint( pt );
|
|
|
|
// Now tell choreo view
|
|
CExpression *exp = active->GetExpression( m_nDragCell );
|
|
if ( exp && maybeTool )
|
|
{
|
|
if ( IsWindowOrChild( g_pChoreoView, maybeTool ) )
|
|
{
|
|
if ( g_pChoreoView->CreateExpressionEvent( pt.x, pt.y, active, exp ) )
|
|
{
|
|
return iret;
|
|
}
|
|
}
|
|
|
|
if ( IsWindowOrChild( g_pExpressionTool, maybeTool ) )
|
|
{
|
|
if ( g_pExpressionTool->SetFlexAnimationTrackFromExpression( pt.x, pt.y, active, exp ) )
|
|
{
|
|
return iret;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
if ( active )
|
|
{
|
|
// Over a new cell
|
|
if ( cell >= 0 &&
|
|
cell < active->GetNumExpressions() &&
|
|
cell != m_nCurCell &&
|
|
m_nCurCell != -1 )
|
|
{
|
|
// Swap cells
|
|
CExpression *exp = active->GetExpression( m_nCurCell );
|
|
if ( exp )
|
|
{
|
|
active->SwapExpressionOrder( m_nCurCell, cell );
|
|
active->SetDirty( true );
|
|
active->SelectExpression( cell );
|
|
}
|
|
}
|
|
}
|
|
}
|
|
break;
|
|
case mxEvent::Size:
|
|
{
|
|
int width = w2();
|
|
|
|
int ch = GetCaptionHeight();
|
|
|
|
g_pExpressionClass->setBounds( 5, 5 + ch, width - 120, 20 );
|
|
|
|
m_pABButton->setBounds( width - 60, 4 + ch, 60, 16 );
|
|
m_pThumbnailIncreaseButton->setBounds( width - 60 - 40, 4 + ch, 16, 16 );
|
|
m_pThumbnailDecreaseButton->setBounds( width - 60 - 20, 4 + ch, 16, 16 );
|
|
|
|
m_nTopOffset = 0;
|
|
RepositionSlider();
|
|
|
|
redraw();
|
|
iret = 1;
|
|
}
|
|
break;
|
|
case mxEvent::MouseWheeled:
|
|
{
|
|
// Figure out cell #
|
|
POINT pt;
|
|
|
|
pt.x = event->x;
|
|
pt.y = event->y;
|
|
|
|
ScreenToClient( (HWND)getHandle(), &pt );
|
|
|
|
if ( event->height < 0 )
|
|
{
|
|
m_nTopOffset = min( m_nTopOffset + 10, slScrollbar->getMaxValue() );
|
|
}
|
|
else
|
|
{
|
|
m_nTopOffset = max( m_nTopOffset - 10, 0 );
|
|
}
|
|
RepositionSlider();
|
|
redraw();
|
|
iret = 1;
|
|
}
|
|
break;
|
|
};
|
|
|
|
if ( iret )
|
|
{
|
|
SetActiveTool( this );
|
|
}
|
|
return iret;
|
|
}
|
|
|
|
void mxExpressionTray::ET_Undo( int cell )
|
|
{
|
|
g_pControlPanel->UndoExpression( cell );
|
|
}
|
|
|
|
void mxExpressionTray::ET_Redo( int cell )
|
|
{
|
|
g_pControlPanel->RedoExpression( cell );
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose:
|
|
//-----------------------------------------------------------------------------
|
|
void mxExpressionTray::ThumbnailIncrease( void )
|
|
{
|
|
if ( m_nSnapshotWidth + THUMBNAIL_SIZE_STEP <= MAX_THUMBNAILSIZE )
|
|
{
|
|
m_nSnapshotWidth += THUMBNAIL_SIZE_STEP;
|
|
g_viewerSettings.thumbnailsize = m_nSnapshotWidth;
|
|
m_nSnapshotHeight = m_nSnapshotWidth + m_nDescriptionHeight;
|
|
|
|
Con_Printf( "Thumbnail size %i x %i\n", m_nSnapshotWidth, m_nSnapshotWidth );
|
|
|
|
redraw();
|
|
}
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose:
|
|
//-----------------------------------------------------------------------------
|
|
void mxExpressionTray::ThumbnailDecrease( void )
|
|
{
|
|
if ( m_nSnapshotWidth - THUMBNAIL_SIZE_STEP >= MIN_THUMBNAILSIZE )
|
|
{
|
|
m_nSnapshotWidth -= THUMBNAIL_SIZE_STEP;
|
|
g_viewerSettings.thumbnailsize = m_nSnapshotWidth;
|
|
m_nSnapshotHeight = m_nSnapshotWidth + m_nDescriptionHeight;
|
|
|
|
Con_Printf( "Thumbnail size %i x %i\n", m_nSnapshotWidth, m_nSnapshotWidth );
|
|
|
|
redraw();
|
|
}
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose:
|
|
//-----------------------------------------------------------------------------
|
|
void mxExpressionTray::RestoreThumbnailSize( void )
|
|
{
|
|
m_nSnapshotWidth = g_viewerSettings.thumbnailsize;
|
|
m_nSnapshotWidth = max( MIN_THUMBNAILSIZE, m_nSnapshotWidth );
|
|
m_nSnapshotWidth = min( MAX_THUMBNAILSIZE, m_nSnapshotWidth );
|
|
|
|
g_viewerSettings.thumbnailsize = m_nSnapshotWidth;
|
|
|
|
m_nSnapshotHeight = m_nSnapshotWidth + m_nDescriptionHeight;
|
|
|
|
redraw();
|
|
}
|
|
|
|
void mxExpressionTray::ReloadBitmaps( void )
|
|
{
|
|
CExpClass *cl;
|
|
int c = expressions->GetNumClasses();
|
|
EnableStickySnapshotMode();
|
|
for ( int i = 0 ; i < c; i++ )
|
|
{
|
|
cl = expressions->GetClass( i );
|
|
if ( !cl )
|
|
continue;
|
|
|
|
cl->ReloadBitmaps();
|
|
}
|
|
DisableStickySnapshotMode();
|
|
redraw();
|
|
}
|
|
|
|
bool IsUsingPerPlayerExpressions()
|
|
{
|
|
bool bPerPlayerExpressions = false;
|
|
if ( CommandLine()->CheckParm( "-perplayerexpressions" ) )
|
|
{
|
|
bPerPlayerExpressions = true;
|
|
}
|
|
else
|
|
{
|
|
// Returns the search path, each path is separated by ;s. Returns the length of the string returned
|
|
char pSearchPath[2048];
|
|
if ( g_pFullFileSystem->GetSearchPath( "GAME", false, pSearchPath, sizeof(pSearchPath) ) )
|
|
{
|
|
Q_FixSlashes( pSearchPath );
|
|
if ( Q_stristr( pSearchPath, "\\tf" ) )
|
|
{
|
|
bPerPlayerExpressions = true;
|
|
}
|
|
}
|
|
}
|
|
return bPerPlayerExpressions;
|
|
}
|
|
|
|
void mxExpressionTray::OnModelChanged()
|
|
{
|
|
if ( IsUsingPerPlayerExpressions() )
|
|
{
|
|
Msg( "Closing current phoneme set\n" );
|
|
|
|
if ( !g_pControlPanel->Closeall() )
|
|
return;
|
|
|
|
// See if per-model overrides exist for this model
|
|
char fn[ MAX_PATH ];
|
|
Q_snprintf( fn, sizeof( fn ), "expressions/%s/phonemes/phonemes.txt", models->GetActiveModelName() );
|
|
|
|
// Load appropriate classes
|
|
char rootDir[ MAX_PATH ];
|
|
Q_snprintf( rootDir, sizeof( rootDir ), "%s/phonemes/", models->GetActiveModelName() );
|
|
FacePoser_SetPhonemeRootDir( rootDir );
|
|
|
|
FacePoser_EnsurePhonemesLoaded();
|
|
}
|
|
|
|
ReloadBitmaps();
|
|
RestoreThumbnailSize();
|
|
} |