Ejemplo n.º 1
0
	virtual void ShowRightClickMenu( int mx, int my )
	{
		IFacePoserToolWindow *tool = GetSelectedTool();
		if ( !tool )
			return;

		mxWindow *toolw = tool->GetMxWindow();
		if ( !toolw )
			return;

		mxPopupMenu *pop = new mxPopupMenu();
		Assert( pop );

		bool isVisible = toolw->isVisible();
		bool isLocked = tool->IsLocked();

		pop->add( isVisible ? "Hide" : "Show", IDC_TOOL_TOGGLEVISIBILITY );
		pop->add( isLocked ? "Unlock" : "Lock", IDC_TOOL_TOGGLELOCK );

		// Convert click position
		POINT pt;
		pt.x = mx;
		pt.y = my;

		/*
		ClientToScreen( (HWND)getHandle(), &pt );
		ScreenToClient( (HWND)g_MDLViewer->getHandle(), &pt );
		*/

		// Convert coordinate space
		pop->popup( this, pt.x, pt.y );
	}
Ejemplo n.º 2
0
void MDLViewer::OnCascade()
{
	int i;
	int c = IFacePoserToolWindow::GetToolCount();
	int viscount = CountVisibleTools();

	int x = 0, y = 0;

	int offset = 20;

	int wide = workspace->w2() - viscount * offset;
	int tall = ( workspace->h2() - viscount * offset ) / 2;

	for ( i = 0; i < c; i++ )
	{
		IFacePoserToolWindow *tool = IFacePoserToolWindow::GetTool( i );
		mxWindow *w = tool->GetMxWindow();
		if ( !w->isVisible() )
			continue;

		w->setBounds( x, y, wide, tall );
		x += offset;
		y += offset;
	}
}
Ejemplo n.º 3
0
void MDLViewer::UpdateWindowMenu( void )
{
	int c = IFacePoserToolWindow::GetToolCount();
	for ( int i = 0; i < c ; i++ )
	{
		IFacePoserToolWindow *tool = IFacePoserToolWindow::GetTool( i );
		menuWindow->setChecked( IDC_WINDOW_FIRSTTOOL + i, tool->GetMxWindow()->isVisible() );
	}
}
Ejemplo n.º 4
0
	void	Init( void )
	{
		int c = IFacePoserToolWindow::GetToolCount();
		int i;
		for ( i = 0; i < c ; i++ )
		{
			IFacePoserToolWindow *tool = IFacePoserToolWindow::GetTool( i );
			add( tool->GetDisplayNameRoot() );
		}
	}
Ejemplo n.º 5
0
void MDLViewer::SaveWindowPositions( void )
{
	// Save the model viewer position
	SavePosition();

	int c = IFacePoserToolWindow::GetToolCount();
	for ( int i = 0; i < c; i++ )
	{
		IFacePoserToolWindow *w = IFacePoserToolWindow::GetTool( i );
		w->SavePosition();
	}
}
Ejemplo n.º 6
0
void MDLViewer::OnShowAll()
{
	int c = IFacePoserToolWindow::GetToolCount();
	for ( int i = 0; i < c; i++ )
	{
		IFacePoserToolWindow *tool = IFacePoserToolWindow::GetTool( i );
		mxWindow *w = tool->GetMxWindow();

		w->setVisible( true );
	}

	UpdateWindowMenu();
}
Ejemplo n.º 7
0
	virtual int	handleEvent( mxEvent *event )
	{
		int iret = 0;
		switch ( event->event )
		{
		case mxEvent::Action:
			{
				iret = 1;
				switch ( event->action )
				{
				default:
					iret = 0;
					break;
				case IDC_TOOL_TOGGLEVISIBILITY:
					{
						IFacePoserToolWindow *tool = GetSelectedTool();
						if ( tool )
						{
							mxWindow *toolw = tool->GetMxWindow();
							if ( toolw )
							{
								toolw->setVisible( !toolw->isVisible() );
								g_MDLViewer->UpdateWindowMenu();
							}
						}
					}
					break;
				case IDC_TOOL_TOGGLELOCK:
					{
						IFacePoserToolWindow *tool = GetSelectedTool();
						if ( tool )
						{
							tool->ToggleLockedState();
						}
					}
					break;
				}
			}
			break;
		default:
			break;
		}
		if ( iret )
			return iret;
		return BaseClass::handleEvent( event );
	}
Ejemplo n.º 8
0
static int CountVisibleTools( void )
{
	int i;
	int c = IFacePoserToolWindow::GetToolCount();
	int viscount = 0;

	for ( i = 0; i < c; i++ )
	{
		IFacePoserToolWindow *tool = IFacePoserToolWindow::GetTool( i );
		mxWindow *w = tool->GetMxWindow();
		if ( !w->isVisible() )
			continue;

		viscount++;
	}

	return viscount;
}
Ejemplo n.º 9
0
void MDLViewer::LoadWindowPositions( void )
{
	// NOTE: Don't do this here, we do the mdlviewer position earlier in startup
	// LoadPosition();

	int w = this->w();
	int h = this->h();

	g_viewerSettings.width = w;
	g_viewerSettings.height = h;

	int c = IFacePoserToolWindow::GetToolCount();
	for ( int i = 0; i < c; i++ )
	{
		IFacePoserToolWindow *w = IFacePoserToolWindow::GetTool( i );
		w->LoadPosition();
	}
}
Ejemplo n.º 10
0
	void	HandleWindowSelect( void )
	{
		extern double realtime;
		IFacePoserToolWindow *tool = GetSelectedTool();
		if ( !tool )
			return;

		bool doubleclicked = false;

		double curtime = realtime;
		int clickedItem = getSelectedIndex();

		if ( clickedItem == m_nLastSelected )
		{
			if ( curtime < m_flLastSelectedTime + WINDOW_DOUBLECLICK_TIME )
			{
				doubleclicked = true;
			}
		}

		m_flLastSelectedTime = curtime;
		m_nLastSelected = clickedItem;

		mxWindow *toolw = tool->GetMxWindow();
		if ( !toolw )
			return;

		if ( doubleclicked )
		{
			toolw->setVisible( !toolw->isVisible() );
			m_flLastSelectedTime = -1;
		}

		if ( !toolw->isVisible() )
		{
			return;
		}

		// Move window to front
		HWND wnd = (HWND)tool->GetMxWindow()->getHandle();
		SetFocus( wnd );
		SetWindowPos( wnd, HWND_TOP, 0, 0, 0, 0, SWP_NOMOVE | SWP_NOSIZE | SWP_SHOWWINDOW);
	}
//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
void mxStatusWindow::DrawActiveTool()
{
	RECT rcTool;
	rcTool.left = 0;
	rcTool.top = GetCaptionHeight() + 2;
	rcTool.bottom = h2();
	rcTool.right = w2() - 16;

	rcTool.bottom = rcTool.top + 10;
	rcTool.left = rcTool.right - 500;

	char sz[ 256 ];

	IFacePoserToolWindow *activeTool = IFacePoserToolWindow::GetActiveTool();

	static float lastrealtime = 0.0f;

	float dt = (float)realtime - lastrealtime;
	dt = clamp( dt, 0.0f, 1.0f );

	float fps = 0.0f;
	if ( dt > 0.0001f )
	{
		fps = 1.0f / dt;
	}

	sprintf( sz, "%s (%i) at %.3f (%.2f fps) (soundcount %i)", 
		activeTool ? activeTool->GetToolName() : "None", 
		g_MDLViewer->GetCurrentFrame(), 
		(float)realtime, 
		fps,
		models->CountActiveSources() );

	lastrealtime = realtime;

	int len = CChoreoWidgetDrawHelper::CalcTextWidth( "Courier New", 10, FW_NORMAL, sz );

	CChoreoWidgetDrawHelper helper( this, rcTool, RGB( 32, 0, 0 ) );

	rcTool.left = rcTool.right - len - 15;

	helper.DrawColoredText( "Courier New", 10, FW_NORMAL, RGB( 255, 255, 200 ), rcTool, sz );
}
Ejemplo n.º 12
0
void MDLViewer::DoTile( int x, int y )
{
	int c = IFacePoserToolWindow::GetToolCount();

	int vis = CountVisibleTools();

	if ( x < 1 )
		x = 1;
	if ( y < 1 )
		y = 1;

	int wide = workspace->w2() / y;
	int tall = workspace->h2() / x;

	int obj = 0;

	for ( int row = 0 ; row < x ; row++ )
	{
		for  ( int col = 0; col < y; col++ )
		{
			bool found = false;
			while ( 1 )
			{
				if ( obj >= c )
					break;

				IFacePoserToolWindow *tool = IFacePoserToolWindow::GetTool( obj++ );
				mxWindow *w = tool->GetMxWindow();
				if ( w->isVisible() )
				{
					w->setBounds( col * wide, row * tall, wide, tall );

					found = true;
					break;
				}
			}

			if ( !found )
				break;
		}
	}
}
Ejemplo n.º 13
0
MDLViewer::MDLViewer ()
: mxWindow (0, 0, 0, 0, 0, g_appTitle, mxWindow::Normal)
{
	int i;

	g_MDLViewer = this;

	FacePoser_MakeToolWindow( this, false );

	workspace = new CMDLViewerWorkspace( this, 0, 0, 500, 500, "" );
	windowtab = new CMDLViewerWindowTab( this, 0, 500, 500, 20, IDC_WINDOW_TAB );
	modeltab = new CMDLViewerModelTab( this, 500, 500, 100, 20, IDC_MODEL_TAB );
	gridsettings = new CMDLViewerGridSettings( this, 0, 500, 500, 20 );
	modeltab->SetRightJustify( true );

	g_pStatusWindow = new mxStatusWindow( workspace, 0, 0, 1024, 150, "" );
	g_pStatusWindow->setVisible( true );

	InitViewerSettings( "faceposer" );
	g_viewerSettings.speechapiindex = SPEECH_API_LIPSINC;
	g_viewerSettings.flHeadTurn = 0.0f;
	g_viewerSettings.m_iEditAttachment = -1;

	LoadPosition();
	// ShowWindow( (HWND)getHandle(), SW_SHOWMAXIMIZED );

	g_pStatusWindow->setBounds(  0, h2() - 150, w2(), 150 );

	Con_Printf( "MDLViewer started\n" );

	Con_Printf( "CSoundEmitterSystemBase::Init()\n" );
	soundemitter->BaseInit();

	Con_Printf( "Creating menu bar\n" );

	// create menu stuff
	mb = new mxMenuBar (this);
	menuFile = new mxMenu ();
	menuOptions = new mxMenu ();
	menuWindow = new mxMenu ();
	menuHelp = new mxMenu ();
	menuEdit = new mxMenu ();
	menuExpressions = new mxMenu();
	menuChoreography = new mxMenu();

	mb->addMenu ("File", menuFile);
	mb->addMenu( "Edit", menuEdit );
	mb->addMenu ("Options", menuOptions);
	mb->addMenu ( "Expression", menuExpressions );
	mb->addMenu ( "Choreography", menuChoreography );
	mb->addMenu ("Window", menuWindow);
	mb->addMenu ("Help", menuHelp);

	mxMenu *menuRecentModels = new mxMenu ();
	menuRecentModels->add ("(empty)", IDC_FILE_RECENTMODELS1);
	menuRecentModels->add ("(empty)", IDC_FILE_RECENTMODELS2);
	menuRecentModels->add ("(empty)", IDC_FILE_RECENTMODELS3);
	menuRecentModels->add ("(empty)", IDC_FILE_RECENTMODELS4);

	menuFile->add ("Load Model...", IDC_FILE_LOADMODEL);
	menuFile->add( "Refresh\tF5", IDC_FILE_REFRESH );

	menuFile->addSeparator();

	menuFile->add ("Load Background Texture...", IDC_FILE_LOADBACKGROUNDTEX);
	menuFile->add ("Load Ground Texture...", IDC_FILE_LOADGROUNDTEX);
	menuFile->addSeparator ();
	menuFile->add ("Unload Ground Texture", IDC_FILE_UNLOADGROUNDTEX);
	menuFile->addSeparator ();
	menuFile->addMenu ("Recent Models", menuRecentModels);
	menuFile->addSeparator ();
	menuFile->add ("Exit", IDC_FILE_EXIT);

	menuFile->setEnabled(IDC_FILE_LOADBACKGROUNDTEX, false);
	menuFile->setEnabled(IDC_FILE_LOADGROUNDTEX, false);
	menuFile->setEnabled(IDC_FILE_UNLOADGROUNDTEX, false);

	menuEdit->add( "&Undo\tCtrl+Z", IDC_EDIT_UNDO );
	//menuFile->setEnabled( IDC_EDIT_UNDO, false );
	menuEdit->add( "&Redo\tCtrl+Y", IDC_EDIT_REDO );
	//menuFile->setEnabled( IDC_EDIT_REDO, false );

	menuEdit->addSeparator();

	menuEdit->add( "&Copy\tCtrl+C", IDC_EDIT_COPY );
	menuEdit->add( "&Paste\tCtrl+V", IDC_EDIT_PASTE );

	menuOptions->add ("Background Color...", IDC_OPTIONS_COLORBACKGROUND);
	menuOptions->add ("Ground Color...", IDC_OPTIONS_COLORGROUND);
	menuOptions->add ("Light Color...", IDC_OPTIONS_COLORLIGHT);
	menuOptions->addSeparator ();
	menuOptions->add ("Center View", IDC_OPTIONS_CENTERVIEW);
	menuOptions->add ("Center on Face", IDC_OPTIONS_CENTERONFACE );
#ifdef WIN32
	menuOptions->addSeparator ();
	menuOptions->add ("Make Screenshot...", IDC_OPTIONS_MAKESCREENSHOT);
	//menuOptions->add ("Dump Model Info", IDC_OPTIONS_DUMP);
#endif

	menuExpressions->add( "New...", IDC_EXPRESSIONS_NEW );
	menuExpressions->addSeparator ();
	menuExpressions->add( "Load...", IDC_EXPRESSIONS_LOAD );
	menuExpressions->add( "Save", IDC_EXPRESSIONS_SAVE );
	menuExpressions->addSeparator ();
	menuExpressions->add( "Export to VFE", IDC_EXPRESSIONS_EXPORT );
	menuExpressions->addSeparator ();
	menuExpressions->add( "Close class", IDC_EXPRESSIONS_CLOSE );
	menuExpressions->add( "Close all classes", IDC_EXPRESSIONS_CLOSEALL );
	menuExpressions->addSeparator();
	menuExpressions->add( "Recreate all bitmaps", IDC_EXPRESSIONS_REDOBITMAPS );

	menuChoreography->add( "New...", IDC_CHOREOSCENE_NEW );
	menuChoreography->addSeparator();
	menuChoreography->add( "Load...", IDC_CHOREOSCENE_LOAD );
	menuChoreography->add( "Save", IDC_CHOREOSCENE_SAVE );
	menuChoreography->add( "Save As...", IDC_CHOREOSCENE_SAVEAS );
	menuChoreography->addSeparator();
	menuChoreography->add( "Close", IDC_CHOREOSCENE_CLOSE );
	menuChoreography->addSeparator();
	menuChoreography->add( "Add Actor...", IDC_CHOREOSCENE_ADDACTOR );

#ifdef WIN32
	menuHelp->add ("Goto Homepage...", IDC_HELP_GOTOHOMEPAGE);
	menuHelp->addSeparator ();
#endif
	menuHelp->add ("About...", IDC_HELP_ABOUT);

	// create the Material System window
	Con_Printf( "Creating 3D View\n" );
	g_pMatSysWindow = new MatSysWindow (workspace, 0, 0, 0, 0, "", mxWindow::Normal);

	Con_Printf( "Creating control panel\n" );
	g_pControlPanel = new ControlPanel (workspace);

	Con_Printf( "Creating phoneme editor\n" );
	g_pPhonemeEditor = new PhonemeEditor( workspace );

	Con_Printf( "Creating expression tool\n" );
	g_pExpressionTool = new ExpressionTool( workspace );

	Con_Printf( "Creating gesture tool\n" );
	g_pGestureTool = new GestureTool( workspace );

	Con_Printf( "Creating ramp tool\n" );
	g_pRampTool = new RampTool( workspace );

	Con_Printf( "Creating scene ramp tool\n" );
	g_pSceneRampTool = new SceneRampTool( workspace );

	Con_Printf( "Creating expression tray\n" );
	g_pExpressionTrayTool = new mxExpressionTray( workspace, IDC_EXPRESSIONTRAY );

	Con_Printf( "Creating flex slider window\n" );
	g_pFlexPanel = new FlexPanel( workspace );

	Con_Printf( "Creating choreography view\n" );
	g_pChoreoView = new CChoreoView( workspace, 200, 200, 400, 300, 0 );
	// Choreo scene file drives main window title name
	g_pChoreoView->SetUseForMainWindowTitle( true );

	Con_Printf( "IFacePoserToolWindow::Init\n" );

	IFacePoserToolWindow::Init();

	Con_Printf( "windowtab->Init\n" );
	
	windowtab->Init();

	Con_Printf( "loadRecentFiles\n" );

	loadRecentFiles ();
	initRecentFiles ();

	Con_Printf( "LoadWindowPositions\n" );

	LoadWindowPositions();

	Con_Printf( "RestoreThumbnailSize\n" );

	g_pExpressionTrayTool->RestoreThumbnailSize();

	Con_Printf( "Add Tool Windows\n" );

	int c = IFacePoserToolWindow::GetToolCount();
	for ( i = 0; i < c ; i++ )
	{
		IFacePoserToolWindow *tool = IFacePoserToolWindow::GetTool( i );
		menuWindow->add( tool->GetToolName(), IDC_WINDOW_FIRSTTOOL + i );
	}

	menuWindow->addSeparator();
	menuWindow->add( "Cascade", IDC_WINDOW_CASCADE );
	menuWindow->addSeparator();
	menuWindow->add( "Tile", IDC_WINDOW_TILE );
	menuWindow->add( "Tile Horizontally", IDC_WINDOW_TILE_HORIZ );
	menuWindow->add( "Tile Vertically", IDC_WINDOW_TILE_VERT );
	menuWindow->addSeparator();
	menuWindow->add( "Hide All", IDC_WINDOW_HIDEALL );
	menuWindow->add( "Show All", IDC_WINDOW_SHOWALL );

	Con_Printf( "UpdateWindowMenu\n" );

	UpdateWindowMenu();

	m_nCurrentFrame = 0;

	Con_Printf( "gridsettings->Init()\n" );

	gridsettings->Init();

	Con_Printf( "Model viewer created\n" );
}
Ejemplo n.º 14
0
int MDLViewer::handleEvent (mxEvent *event)
{
	int iret = 0;

	switch (event->event)
	{
	case mxEvent::Size:
		{
			int width = w2();
			int height = h2();

			workspace->setBounds( 0, 0, width, height - WINDOW_TAB_OFFSET );
			int gridsettingswide = 100;
			int gridstart = width - gridsettingswide - 5;
			int windowwide = gridstart * 0.6f;
			int modelwide = gridstart * 0.4f;

			gridsettings->setBounds( gridstart, height - WINDOW_TAB_OFFSET + 1, gridsettingswide, WINDOW_TAB_OFFSET - 2 );

			windowtab->setBounds( 0, height - WINDOW_TAB_OFFSET, windowwide, WINDOW_TAB_OFFSET );
			modeltab->setBounds( windowwide, height - WINDOW_TAB_OFFSET, modelwide, WINDOW_TAB_OFFSET );

			iret = 1;
		}
		break;
	case mxEvent::Action:
		{
			iret = 1;
			switch (event->action)
			{
			case IDC_WINDOW_TAB:
				{
					windowtab->HandleWindowSelect();
				}
				break;
			case IDC_MODEL_TAB:
				{
					modeltab->HandleModelSelect();
				}
				break;
			case IDC_EDIT_COPY:
				{
					Copy();
				}
				break;
				
			case IDC_EDIT_PASTE:
				{
					Paste();
				}
				break;
				
			case IDC_EDIT_UNDO:
				{
					Undo();
				}
				break;
				
			case IDC_EDIT_REDO:
				{
					Redo();
				}
				break;
				
			case IDC_FILE_LOADMODEL:
				{
					const char *ptr = mxGetOpenFileName(
						this, 
						FacePoser_MakeWindowsSlashes( va( "%s/models/", GetGameDirectory() ) ),
						"*.mdl");
					if (ptr)
					{
						LoadModelFile( ptr );
					}
				}
				break;
				
			case IDC_FILE_REFRESH:
				{
					Refresh();
					break;
				}
				
			case IDC_FILE_LOADBACKGROUNDTEX:
			case IDC_FILE_LOADGROUNDTEX:
				{
					const char *ptr = mxGetOpenFileName (this, 0, "*.*");
					if (ptr)
					{
						if (0 /* g_pMatSysWindow->loadTexture (ptr, event->action - IDC_FILE_LOADBACKGROUNDTEX) */)
						{
							if (event->action == IDC_FILE_LOADBACKGROUNDTEX)
								g_pControlPanel->setShowBackground (true);
							else
								g_pControlPanel->setShowGround (true);
							
						}
						else
							mxMessageBox (this, "Error loading texture.", g_appTitle, MX_MB_OK | MX_MB_ERROR);
					}
				}
				break;
				
			case IDC_FILE_UNLOADGROUNDTEX:
				{
					// g_pMatSysWindow->loadTexture (0, 1);
					g_pControlPanel->setShowGround (false);
				}
				break;
				
			case IDC_FILE_RECENTMODELS1:
			case IDC_FILE_RECENTMODELS2:
			case IDC_FILE_RECENTMODELS3:
			case IDC_FILE_RECENTMODELS4:
				{
					int i = event->action - IDC_FILE_RECENTMODELS1;
					
					LoadModelFile( recentFiles[ i ] );
					
					char tmp[256];			
					strcpy (tmp, recentFiles[0]);
					strcpy (recentFiles[0], recentFiles[i]);
					strcpy (recentFiles[i], tmp);
					
					initRecentFiles ();
					
					redraw ();
				}
				break;
				
			case IDC_FILE_EXIT:
				{
					redraw ();
					mx::quit ();
				}
				break;
				
			case IDC_OPTIONS_COLORBACKGROUND:
			case IDC_OPTIONS_COLORGROUND:
			case IDC_OPTIONS_COLORLIGHT:
				{
					float *cols[3] = { g_viewerSettings.bgColor, g_viewerSettings.gColor, g_viewerSettings.lColor };
					float *col = cols[event->action - IDC_OPTIONS_COLORBACKGROUND];
					int r = (int) (col[0] * 255.0f);
					int g = (int) (col[1] * 255.0f);
					int b = (int) (col[2] * 255.0f);
					if (mxChooseColor (this, &r, &g, &b))
					{
						col[0] = (float) r / 255.0f;
						col[1] = (float) g / 255.0f;
						col[2] = (float) b / 255.0f;
					}
				}
				break;
				
			case IDC_OPTIONS_CENTERVIEW:
				g_pControlPanel->centerView ();
				break;
				
			case IDC_OPTIONS_CENTERONFACE:
				g_pControlPanel->CenterOnFace();
				break;
				
			case IDC_OPTIONS_MAKESCREENSHOT:
				{
					char *ptr = (char *) mxGetSaveFileName (this, "", "*.tga");
					if (ptr)
					{
						if (!strstr (ptr, ".tga"))
							strcat (ptr, ".tga");
						// g_pMatSysWindow->dumpViewport (ptr);
					}
				}
				break;
				
			case IDC_OPTIONS_DUMP:
				g_pControlPanel->dumpModelInfo ();
				break;
				
#ifdef WIN32
			case IDC_HELP_GOTOHOMEPAGE:
				ShellExecute (0, "open", "http://www.swissquake.ch/chumbalum-soft/index.html", 0, 0, SW_SHOW);
				break;
#endif
				
			case IDC_HELP_ABOUT:
				mxMessageBox (this,
					"v0.1 (c) 2001, Valve, LLC.  All rights reserved.\r\nBuild Date: "__DATE__"",
					"Valve Face Poser", 
					MX_MB_OK | MX_MB_INFORMATION);
				break;
				
			case IDC_EXPRESSIONS_REDOBITMAPS:
				{
					bool saveOverrides = g_pExpressionTrayTool->GetOverridesShowing();
					g_pExpressionTrayTool->SetOverridesShowing( false );
					CExpClass *active = expressions->GetActiveClass();
					if ( active )
					{
						for ( int i = 0; i < active->GetNumExpressions() ; i++ )
						{
							CExpression *exp = active->GetExpression( i );
							if ( !exp )
								continue;
							
							active->SelectExpression( i );
							exp->CreateNewBitmap( models->GetActiveModelIndex() );
							
							if ( ! ( i % 5 ) )
							{
								g_pExpressionTrayTool->redraw();
							}
						}
						
						if ( active->HasOverrideClass() )
						{
							
							g_pExpressionTrayTool->SetOverridesShowing( true );
							
							CExpClass *oc = active->GetOverrideClass();
							for ( int i = 0; i < oc->GetNumExpressions() ; i++ )
							{
								CExpression *exp = oc->GetExpression( i );
								if ( !exp )
									continue;
								
								oc->SelectExpression( i );
								exp->CreateNewBitmap( models->GetActiveModelIndex() );
								
								if ( ! ( i % 5 ) )
								{
									g_pExpressionTrayTool->redraw();
								}
							}
						}
						active->SelectExpression( 0 );
					}
					
					g_pExpressionTrayTool->SetOverridesShowing( saveOverrides );
				}
				break;
			case IDC_EXPRESSIONS_NEW:
				{
					const char *filename = mxGetSaveFileName( 
						this, 
						FacePoser_MakeWindowsSlashes( va( "%s/expressions/", GetGameDirectory() ) ), 
						"*.txt" );
					if ( filename && filename[ 0 ] )
					{
						char classfile[ 512 ];
						strcpy( classfile, filename );
						StripExtension( classfile );
						DefaultExtension( classfile, ".txt" );
						
						expressions->CreateNewClass( classfile );
					}
				}
				break;
			case IDC_EXPRESSIONS_LOAD:
				{
					const char *filename = NULL;
					
					filename = mxGetOpenFileName( 
						this, 
						FacePoser_MakeWindowsSlashes( va( "%s/expressions/", GetGameDirectory() ) ), 
						"*.txt" );
					if ( filename && filename[ 0 ] )
					{
						expressions->LoadClass( filename );
					}
				}
				break;
				
			case IDC_EXPRESSIONS_SAVE:
				{
					CExpClass *active = expressions->GetActiveClass();
					if ( active )
					{
						active->Save();
						active->Export();
					}
				}
				break;
			case IDC_EXPRESSIONS_EXPORT:
				{
					CExpClass *active = expressions->GetActiveClass();
					if ( active )
					{
						active->Export();
					}
				}
				break;
			case IDC_EXPRESSIONS_CLOSE:
				g_pControlPanel->Close();
				break;
			case IDC_EXPRESSIONS_CLOSEALL:
				g_pControlPanel->Closeall();
				break;
			case IDC_CHOREOSCENE_NEW:
				g_pChoreoView->New();
				break;
			case IDC_CHOREOSCENE_LOAD:
				g_pChoreoView->Load();
				break;
			case IDC_CHOREOSCENE_SAVE:
				g_pChoreoView->Save();
				break;
			case IDC_CHOREOSCENE_SAVEAS:
				g_pChoreoView->SaveAs();
				break;
			case IDC_CHOREOSCENE_CLOSE:
				g_pChoreoView->Close();
				break;
			case IDC_CHOREOSCENE_ADDACTOR:
				g_pChoreoView->NewActor();
				break;
			case IDC_WINDOW_TILE:
				{
					OnTile();
				}
				break;
			case IDC_WINDOW_TILE_HORIZ:
				{
					OnTileHorizontally();
				}
				break;
			case IDC_WINDOW_TILE_VERT:
				{
					OnTileVertically();
				}
				break;
			case IDC_WINDOW_CASCADE:
				{
					OnCascade();
				}
				break;
			case IDC_WINDOW_HIDEALL:
				{
					OnHideAll();
				}
				break;
			case IDC_WINDOW_SHOWALL:
				{
					OnShowAll();
				}
				break;
			default:
				{
					iret = 0;
					int tool_number = event->action - IDC_WINDOW_FIRSTTOOL;
					int max_tools = IDC_WINDOW_LASTTOOL - IDC_WINDOW_FIRSTTOOL;
					
					if ( tool_number >= 0 && 
						tool_number <= max_tools && 
						tool_number < IFacePoserToolWindow::GetToolCount() )
					{
						iret = 1;
						IFacePoserToolWindow *tool = IFacePoserToolWindow::GetTool( tool_number );
						if ( tool )
						{
							mxWindow *toolw = tool->GetMxWindow();
							
							bool wasvisible = toolw->isVisible();
							toolw->setVisible( !wasvisible );
							
							g_MDLViewer->UpdateWindowMenu();

						}
					}
				}
				break;
			} //switch (event->action)
		} // mxEvent::Action
		break;
	case KeyDown:
		{
			g_pMatSysWindow->handleEvent(event);
			iret = 1;
		}
		break;
	case mxEvent::Activate:
		{
			if (event->action)
			{
				mx::setIdleWindow( g_pMatSysWindow );
			}
			else
			{
				mx::setIdleWindow( 0 );
			}
			iret = 1;
		}
		break;
	} // event->event
	
	return iret;
}