Serious-Engine/Sources/Modeler/MainFrm.cpp
2016-03-11 15:57:17 +02:00

1077 lines
31 KiB
C++

/* Copyright (c) 2002-2012 Croteam Ltd. All rights reserved. */
// MainFrm.cpp : implementation of the CMainFrame class
//
#include "stdafx.h"
#include <Engine/Templates/Stock_CTextureData.h>
#ifdef _DEBUG
#undef new
#define new DEBUG_NEW
#undef THIS_FILE
static char THIS_FILE[] = __FILE__;
#endif
ENGINE_API extern INDEX snd_iFormat;
/////////////////////////////////////////////////////////////////////////////
// CMainFrame
extern UINT APIENTRY ModelerFileRequesterHook( HWND hdlg, UINT uiMsg, WPARAM wParam, LPARAM lParam);
IMPLEMENT_DYNAMIC(CMainFrame, CMDIFrameWnd)
BEGIN_MESSAGE_MAP(CMainFrame, CMDIFrameWnd)
//{{AFX_MSG_MAP(CMainFrame)
ON_WM_CREATE()
ON_WM_CLOSE()
ON_COMMAND(ID_VIEW_ANIMCONTROL, OnViewAnimControl)
ON_UPDATE_COMMAND_UI(ID_VIEW_ANIMCONTROL, OnUpdateViewAnimControl)
ON_UPDATE_COMMAND_UI(ID_VIEW_INFO, OnUpdateShowInfo)
ON_COMMAND(ID_VIEW_INFO, OnViewInfo)
ON_COMMAND(ID_VIEW_COLOR_PALETTE, OnViewColorPalette)
ON_UPDATE_COMMAND_UI(ID_VIEW_COLOR_PALETTE, OnUpdateViewColorPalette)
ON_COMMAND(ID_FILE_CREATE_TEXTURE, OnFileCreateTexture)
ON_COMMAND(ID_VIEW_TEXTURECONTROL, OnViewTexturecontrol)
ON_UPDATE_COMMAND_UI(ID_VIEW_TEXTURECONTROL, OnUpdateViewTexturecontrol)
ON_COMMAND(ID_VIEW_MIPLIGHTCONTROL, OnViewMiplightcontrol)
ON_UPDATE_COMMAND_UI(ID_VIEW_MIPLIGHTCONTROL, OnUpdateViewMiplightcontrol)
ON_COMMAND(ID_VIEW_SCRIPTCONTROL, OnViewScriptcontrol)
ON_UPDATE_COMMAND_UI(ID_VIEW_SCRIPTCONTROL, OnUpdateViewScriptcontrol)
ON_COMMAND(ID_VIEW_RENDERCONTROL, OnViewRendercontrol)
ON_UPDATE_COMMAND_UI(ID_VIEW_RENDERCONTROL, OnUpdateViewRendercontrol)
ON_WM_CANCELMODE()
ON_WM_INITMENU()
ON_COMMAND(ID_VIEW_STAINSCONTROL, OnViewStainscontrol)
ON_UPDATE_COMMAND_UI(ID_VIEW_STAINSCONTROL, OnUpdateViewStainscontrol)
ON_COMMAND(ID_STAINS_ADD, OnStainsAdd)
ON_COMMAND(ID_STAINS_REMOVE, OnStainsRemove)
ON_COMMAND(ID_VIEW_PATCHES_PALETTE, OnViewPatchesPalette)
ON_UPDATE_COMMAND_UI(ID_STAINS_REMOVE, OnUpdateStainsRemove)
ON_COMMAND(ID_VIEW_ROTATE, OnViewRotate)
ON_UPDATE_COMMAND_UI(ID_VIEW_ROTATE, OnUpdateViewRotate)
ON_COMMAND(ID_TOGGLE_ALL_BARS, OnToggleAllBars)
ON_COMMAND(ID_VIEW_MAPPING, OnViewMapping)
ON_UPDATE_COMMAND_UI(ID_VIEW_MAPPING, OnUpdateViewMapping)
ON_WM_ACTIVATEAPP()
ON_COMMAND(ID_EDIT_SPECULAR, OnEditSpecular)
ON_COMMAND(ID_CREATE_REFLECTION_TEXTURE, OnCreateReflectionTexture)
ON_COMMAND(ID_HELP_FINDER, OnHelpFinder)
ON_COMMAND(ID_VIEW_FXCONTROL, OnViewFxcontrol)
ON_UPDATE_COMMAND_UI(ID_VIEW_FXCONTROL, OnUpdateViewFxcontrol)
ON_COMMAND(ID_WINDOW_TOGGLEMAX, OnWindowTogglemax)
ON_COMMAND(ID_TESSELLATE_LESS, OnTessellateLess)
ON_COMMAND(ID_TESSELLATE_MORE, OnTessellateMore)
//}}AFX_MSG_MAP
// Global help commands - modified to use html-help
//ON_COMMAND(ID_HELP_FINDER, CMDIFrameWnd::OnHelpFinder)
ON_COMMAND(ID_DEFAULT_HELP, OnHelpFinder)
ON_COMMAND(ID_HELP, OnHelpFinder)
ON_COMMAND(ID_CONTEXT_HELP, CMDIFrameWnd::OnContextHelp)
END_MESSAGE_MAP()
static UINT indicators[] =
{
ID_SEPARATOR, // status line indicator
ID_SEPARATOR,
ID_INDICATOR_CAPS,
ID_INDICATOR_NUM,
ID_INDICATOR_SCRL,
};
/////////////////////////////////////////////////////////////////////////////
// sets message for modeler's "new progress dialog"
void SetProgressMessage( char *strMessage)
{
CMainFrame* pMainFrame = STATIC_DOWNCAST(CMainFrame, AfxGetMainWnd());
pMainFrame->m_NewProgress.m_strNewMessage = CTString( strMessage);
pMainFrame->m_NewProgress.UpdateData( FALSE);
}
// sets range of modeler's "new progress dialog"
void SetProgressRange( INDEX iProgresSteps)
{
CMainFrame* pMainFrame = STATIC_DOWNCAST(CMainFrame, AfxGetMainWnd());
pMainFrame->m_NewProgress.m_NewProgressLine.SetRange( 0, (short)iProgresSteps);
}
// sets current modeler's "new progress dialog" state
void SetProgressState( INDEX iCurrentStep)
{
CMainFrame* pMainFrame = STATIC_DOWNCAST(CMainFrame, AfxGetMainWnd());
pMainFrame->m_NewProgress.m_NewProgressLine.SetPos( iCurrentStep);
}
/////////////////////////////////////////////////////////////////////////////
// CMainFrame construction/destruction
CMainFrame::CMainFrame()
{
m_pInfoFrame = NULL;
m_dlgPaletteDialog = NULL;
m_dlgPatchesPalette = NULL;
ProgresRoutines.SetProgressMessage = SetProgressMessage;
ProgresRoutines.SetProgressRange = SetProgressRange;
ProgresRoutines.SetProgressState = SetProgressState;
}
CMainFrame::~CMainFrame()
{
// if exists, destroy palette dialog
if( m_dlgPaletteDialog != NULL)
delete( m_dlgPaletteDialog);
if( m_dlgPatchesPalette != NULL)
delete m_dlgPatchesPalette;
}
int CMainFrame::OnCreate(LPCREATESTRUCT lpCreateStruct)
{
const int nDropHeight = 100;
// set same styles for use with all toolbars
DWORD dwToolBarStyles = WS_CHILD | WS_VISIBLE | CBRS_SIZE_DYNAMIC |
CBRS_TOP | CBRS_TOOLTIPS | CBRS_FLYBY | CBRS_GRIPPER;
CRect rectDummy(0,0,0,0);
if (CMDIFrameWnd::OnCreate(lpCreateStruct) == -1)
return -1;
if( (!m_wndToolBar.CreateEx(this, TBSTYLE_FLAT, dwToolBarStyles, rectDummy, IDW_TOOLBAR_MAIN)) ||
(!m_wndToolBar.LoadToolBar(IDR_MAINFRAME)) )
{
TRACE0("Failed to create toolbar\n");
return -1; // fail to create main tool bar
}
if( (!m_wndStatusBar.Create(this, WS_CHILD|WS_VISIBLE|CBRS_BOTTOM, IDW_STATUS_BAR)) ||
!m_wndStatusBar.SetIndicators(indicators, sizeof(indicators)/sizeof(UINT)) )
{
TRACE0("Failed to create status bar\n");
return -1; // fail to create
}
if( (!m_AnimToolBar.CreateEx(this, TBSTYLE_FLAT, dwToolBarStyles, rectDummy, IDW_TOOLBAR_ANIMATION)) ||
(!m_AnimToolBar.LoadToolBar(IDR_ANIMCONTROL)) )
{
TRACE0("Failed to create animation toolbar\n");
return -1; // fail to create animation tool bar
}
if( (!m_TextureToolBar.CreateEx(this, TBSTYLE_FLAT, dwToolBarStyles, rectDummy, IDW_TOOLBAR_TEXTURE)) ||
(!m_TextureToolBar.LoadToolBar(IDR_TEXTURECONTROL)) )
{
TRACE0("Failed to create texture toolbar\n");
return -1; // fail to create texture tool bar
}
if( (!m_FXToolBar.CreateEx(this, TBSTYLE_FLAT, dwToolBarStyles, rectDummy, IDW_TOOLBAR_FX)) ||
(!m_FXToolBar.LoadToolBar(IDR_FX_CONTROL)) )
{
TRACE0("Failed to create FX toolbar\n");
return -1; // fail to create fx tool bar
}
if( (!m_StainsToolBar.CreateEx(this, TBSTYLE_FLAT, dwToolBarStyles, rectDummy, IDW_TOOLBAR_STAINS)) ||
(!m_StainsToolBar.LoadToolBar(IDR_STAINSCONTROL)) )
{
TRACE0("Failed to create stains toolbar\n");
return -1; // fail to create stains tool bar
}
if( (!m_ScriptToolBar.CreateEx(this, TBSTYLE_FLAT, dwToolBarStyles, rectDummy, IDW_TOOLBAR_SCRIPT)) ||
(!m_ScriptToolBar.LoadToolBar(IDR_SCRIPTCONTROL)) )
{
TRACE0("Failed to create script toolbar\n");
return -1; // fail to create script tool bar
}
if( (!m_MipAndLightToolBar.CreateEx(this, TBSTYLE_FLAT, dwToolBarStyles, rectDummy, IDW_TOOLBAR_MIP_AND_LIGHT)) ||
(!m_MipAndLightToolBar.LoadToolBar(IDR_MIPANDLIGHT)) )
{
TRACE0("Failed to create mip and light toolbar\n");
return -1; // fail to create mip and light tool bar
}
if( (!m_RenderControlBar.CreateEx(this, TBSTYLE_FLAT, dwToolBarStyles, rectDummy, IDW_TOOLBAR_RENDER)) ||
(!m_RenderControlBar.LoadToolBar(IDR_RENDERCONTROL)) )
{
TRACE0("Failed to create render control toolbar\n");
return -1; // fail to create render control tool bar
}
static UINT aidRenderControlBar[15] =
{
ID_REND_BBOX_FRAME,
ID_REND_BBOX_ALL,
ID_REND_WIRE_ONOFF,
ID_REND_HIDDEN_LINES,
ID_REND_FLOOR,
ID_REND_NO_TEXTURE,
ID_REND_WHITE_TEXTURE,
ID_REND_SURFACE_COLORS,
ID_REND_ON_COLORS,
ID_REND_OFF_COLORS,
ID_REND_USE_TEXTURE,
ID_SHADOW_WORSE,
ID_SHADOW_BETTER,
ID_TOGGLE_MEASURE_VTX,
ID_VIEW_AXIS,
};
m_RenderControlBar.SetButtons( aidRenderControlBar, 15);
if( (!m_RotateToolBar.CreateEx(this, TBSTYLE_FLAT, dwToolBarStyles, rectDummy, IDW_TOOLBAR_ROTATION)) ||
(!m_RotateToolBar.LoadToolBar(IDR_ROTATE)) )
{
TRACE0("Failed to create rotate surface control toolbar\n");
return -1; // fail to create rotate control tool bar
}
if( (!m_MappingToolBar.CreateEx(this, TBSTYLE_FLAT, dwToolBarStyles, rectDummy, IDW_TOOLBAR_MAPPING)) ||
(!m_MappingToolBar.LoadToolBar(IDR_MAPPING)) )
{
TRACE0("Failed to create mapping control toolbar\n");
return -1; // fail to create mapping control tool bar
}
// Set z-speed edit ctrl
m_AnimToolBar.SetButtonInfo(0, ID_Z_SPEED, TBBS_SEPARATOR, 40);
CRect rectEditSpeed;
m_AnimToolBar.GetItemRect(0, &rectEditSpeed);
rectEditSpeed.top = 2;
rectEditSpeed.right -= 2;
rectEditSpeed.bottom = rectEditSpeed.top + 18;
if (!m_ctrlZSpeed.Create( WS_VISIBLE|WS_BORDER,
rectEditSpeed, &m_AnimToolBar, ID_Z_SPEED) )
{
TRACE0("Failed to create model speed edit control\n");
return FALSE;
}
m_ctrlZSpeed.SetWindowText(L"0");
// Set z-loop edit ctrl
m_AnimToolBar.SetButtonInfo(1, ID_Z_LOOP_TIMES, TBBS_SEPARATOR, 25);
CRect rectEditLoop;
m_AnimToolBar.GetItemRect(1, &rectEditLoop);
rectEditLoop.top = 2;
rectEditLoop.bottom = rectEditLoop.top + 18;
if (!m_ctrlZLoop.Create( WS_VISIBLE|WS_BORDER,
rectEditLoop, &m_AnimToolBar, ID_Z_LOOP_TIMES) )
{
TRACE0("Failed to create model loop edit control\n");
return FALSE;
}
m_ctrlZLoop.SetWindowText(L"4");
m_AnimToolBar.SetButtonInfo(6, ID_ANIM_CHOOSE, TBBS_SEPARATOR, 150);
m_TextureToolBar.SetButtonInfo(2, ID_TEXTURE_CHOOSE, TBBS_SEPARATOR, 150);
m_StainsToolBar.SetButtonInfo(3, ID_STAINS_CHOOSE, TBBS_SEPARATOR, 150);
CRect rect;
m_AnimToolBar.GetItemRect(6, &rect);
rect.top = 2;
rect.bottom = rect.top + nDropHeight;
if (!m_AnimComboBox.Create(
CBS_DROPDOWNLIST|WS_VISIBLE|WS_TABSTOP|WS_VSCROLL,
rect, &m_AnimToolBar, ID_ANIM_CHOOSE))
{
TRACE0("Failed to create animation combo-box\n");
return FALSE;
}
m_TextureToolBar.GetItemRect(2, &rect);
rect.top = 2;
rect.bottom = rect.top + nDropHeight;
if (!m_SkinComboBox.Create(
CBS_DROPDOWNLIST|WS_VISIBLE|WS_TABSTOP|WS_VSCROLL,
rect, &m_TextureToolBar, ID_TEXTURE_CHOOSE))
{
TRACE0("Failed to create texture combo-box\n");
return FALSE;
}
m_StainsToolBar.GetItemRect(3, &rect);
rect.top = 2;
rect.bottom = rect.top + nDropHeight;
if (!m_StainsComboBox.Create(
CBS_DROPDOWNLIST|WS_VISIBLE|WS_TABSTOP|WS_VSCROLL,
rect, &m_StainsToolBar, ID_STAINS_CHOOSE))
{
TRACE0("Failed to create stains combo-box\n");
return FALSE;
}
m_AnimComboBox.AddString( L"None available");
m_AnimComboBox.SetCurSel( 0);
m_SkinComboBox.AddString( L"None available");
m_SkinComboBox.SetCurSel( 0);
m_StainsComboBox.AddString( L"None available");
m_StainsComboBox.SetCurSel( 0);
// Create a font for the comboboxes
LOGFONT logFont;
memset(&logFont, 0, sizeof(logFont));
if (!::GetSystemMetrics(SM_DBCSENABLED))
{
logFont.lfHeight = -11;
logFont.lfWeight = FW_REGULAR;
logFont.lfPitchAndFamily = FF_ROMAN;
logFont.lfOrientation = 10;
logFont.lfQuality = PROOF_QUALITY;
logFont.lfItalic = TRUE;
CString strDefaultFont;
strDefaultFont.LoadString(IDS_DEFAULT_ARIAL);
lstrcpy(logFont.lfFaceName, strDefaultFont);
if( !m_Font.CreateFontIndirect(&logFont))
TRACE0("Could Not create font for combo\n");
else
{
m_ctrlZSpeed.SetFont(&m_Font);
m_ctrlZLoop.SetFont(&m_Font);
m_AnimComboBox.SetFont(&m_Font);
m_SkinComboBox.SetFont(&m_Font);
m_StainsComboBox.SetFont(&m_Font);
}
}
else
{
m_Font.Attach(::GetStockObject(SYSTEM_FONT));
m_ctrlZSpeed.SetFont(&m_Font);
m_ctrlZLoop.SetFont(&m_Font);
m_AnimComboBox.SetFont(&m_Font);
m_SkinComboBox.SetFont(&m_Font);
m_StainsComboBox.SetFont(&m_Font);
}
// create pane for closest surface
UINT nID;
UINT nStyle;
int cxWidth;
m_wndStatusBar.GetPaneInfo( CLOSEST_SURFACE_PANE, nID, nStyle, cxWidth);
cxWidth = 160;
m_wndStatusBar.SetPaneInfo( CLOSEST_SURFACE_PANE, nID, nStyle, cxWidth);
EnableDocking(CBRS_ALIGN_ANY);
m_wndToolBar.SetBarStyle(m_wndToolBar.GetBarStyle() |
CBRS_TOOLTIPS | CBRS_FLYBY | CBRS_SIZE_DYNAMIC);
m_wndToolBar.EnableDocking(CBRS_ALIGN_ANY);
m_AnimToolBar.SetBarStyle(m_AnimToolBar.GetBarStyle() |
CBRS_TOOLTIPS | CBRS_FLYBY | CBRS_SIZE_DYNAMIC);
m_AnimToolBar.EnableDocking(CBRS_ALIGN_ANY);
m_TextureToolBar.SetBarStyle(m_TextureToolBar.GetBarStyle() |
CBRS_TOOLTIPS | CBRS_FLYBY | CBRS_SIZE_DYNAMIC);
m_TextureToolBar.EnableDocking(CBRS_ALIGN_ANY);
m_FXToolBar.SetBarStyle(m_FXToolBar.GetBarStyle() |
CBRS_TOOLTIPS | CBRS_FLYBY | CBRS_SIZE_DYNAMIC);
m_FXToolBar.EnableDocking(CBRS_ALIGN_ANY);
m_StainsToolBar.SetBarStyle(m_StainsToolBar.GetBarStyle() |
CBRS_TOOLTIPS | CBRS_FLYBY | CBRS_SIZE_DYNAMIC);
m_StainsToolBar.EnableDocking(CBRS_ALIGN_ANY);
m_ScriptToolBar.SetBarStyle(m_ScriptToolBar.GetBarStyle() |
CBRS_TOOLTIPS | CBRS_FLYBY | CBRS_SIZE_DYNAMIC);
m_ScriptToolBar.EnableDocking(CBRS_ALIGN_ANY);
m_MipAndLightToolBar.SetBarStyle(m_MipAndLightToolBar.GetBarStyle() |
CBRS_TOOLTIPS | CBRS_FLYBY | CBRS_SIZE_DYNAMIC);
m_MipAndLightToolBar.EnableDocking(CBRS_ALIGN_ANY);
m_RenderControlBar.SetBarStyle(m_RenderControlBar.GetBarStyle() |
CBRS_TOOLTIPS | CBRS_FLYBY | CBRS_SIZE_DYNAMIC);
m_RenderControlBar.EnableDocking(CBRS_ALIGN_ANY);
m_RotateToolBar.SetBarStyle(m_RotateToolBar.GetBarStyle() |
CBRS_TOOLTIPS | CBRS_FLYBY | CBRS_SIZE_DYNAMIC);
m_RotateToolBar.EnableDocking(CBRS_ALIGN_ANY);
m_MappingToolBar.SetBarStyle(m_MappingToolBar.GetBarStyle() |
CBRS_TOOLTIPS | CBRS_FLYBY | CBRS_SIZE_DYNAMIC);
m_MappingToolBar.EnableDocking(CBRS_ALIGN_ANY);
RecalcLayout();
DockControlBar(&m_wndToolBar, AFX_IDW_DOCKBAR_TOP);
DockControlBarRelativeTo(&m_AnimToolBar, &m_wndToolBar, 1, 0);
DockControlBarRelativeTo(&m_TextureToolBar,&m_FXToolBar, 1, 0);
DockControlBarRelativeTo(&m_FXToolBar,&m_AnimToolBar, 1, 0);
DockControlBarRelativeTo(&m_ScriptToolBar,&m_wndToolBar, 0, 15);
DockControlBarRelativeTo(&m_MipAndLightToolBar,&m_ScriptToolBar, 1, 0);
DockControlBarRelativeTo(&m_RotateToolBar, &m_MipAndLightToolBar, 1, 0);
DockControlBarRelativeTo(&m_MappingToolBar, &m_RotateToolBar, 1, 0);
DockControlBarRelativeTo(&m_StainsToolBar,&m_MappingToolBar, 1, 0);
DockControlBar(&m_RenderControlBar, AFX_IDW_DOCKBAR_LEFT);
DockControlBarRelativeTo(&m_MappingToolBar, &m_RenderControlBar, 0, 1);
LoadBarState(_T("General"));
return 0;
}
BOOL CMainFrame::PreCreateWindow(CREATESTRUCT& cs)
{
// TODO: Modify the Window class or styles here by modifying
// the CREATESTRUCT cs
cs.style = WS_OVERLAPPED | WS_CAPTION | FWS_ADDTOTITLE
| WS_THICKFRAME | WS_SYSMENU | WS_MINIMIZEBOX | WS_MAXIMIZEBOX | WS_MAXIMIZE;
//cs.style |= WS_MAXIMIZE;
return CMDIFrameWnd::PreCreateWindow(cs);
}
/////////////////////////////////////////////////////////////////////////////
// CMainFrame diagnostics
#ifdef _DEBUG
void CMainFrame::AssertValid() const
{
CMDIFrameWnd::AssertValid();
}
void CMainFrame::Dump(CDumpContext& dc) const
{
CMDIFrameWnd::Dump(dc);
}
#endif //_DEBUG
/////////////////////////////////////////////////////////////////////////////
// CMainFrame message handlers
void CMainFrame::OnClose()
{
SaveBarState(_T("General"));
CMDIFrameWnd::OnClose();
}
void CMainFrame::OnViewAnimControl()
{
BOOL bVisible = ((m_AnimToolBar.GetStyle() & WS_VISIBLE) != 0);
ShowControlBar(&m_AnimToolBar, !bVisible, FALSE);
RecalcLayout();
}
void CMainFrame::OnUpdateViewAnimControl(CCmdUI* pCmdUI)
{
BOOL bVisible = ((m_AnimToolBar.GetStyle() & WS_VISIBLE) != 0);
pCmdUI->SetCheck(bVisible);
}
void CMainFrame::OnWindowTogglemax()
{
BOOL bIfMaximized;
CChildFrame *pActiveWnd = (CChildFrame *) MDIGetActive( &bIfMaximized);
if( bIfMaximized)
{
MDIRestore( pActiveWnd);
if( !pActiveWnd->m_bAllreadyUnmaximized)
{
pActiveWnd->MoveWindow( 0, 0, 256, 256);
RECT rectClient;
pActiveWnd->GetClientRect( &rectClient);
PIX pixRightWidth = 256+256-rectClient.right+4;
PIX pixRightHeight = 256+256-rectClient.bottom+4;
pActiveWnd->MoveWindow( 0, 0, pixRightWidth, pixRightHeight);
pActiveWnd->m_bAllreadyUnmaximized = TRUE;
}
}
else
{
MDIMaximize( pActiveWnd);
}
theApp.m_chGlobal.MarkChanged();
}
void CMainFrame::HideModelessInfoSheet()
{
ASSERT(m_pInfoFrame != NULL);
m_pInfoFrame->ShowWindow(SW_HIDE);
}
void CMainFrame::OnUpdateShowInfo(CCmdUI* pCmdUI)
{
pCmdUI->Enable( TRUE);
pCmdUI->SetCheck(!(m_pInfoFrame == NULL || !m_pInfoFrame->IsWindowVisible()));
}
void CMainFrame::OnViewInfo()
{
ToggleInfoWindow();
}
void CMainFrame::OnViewColorPalette()
{
if( m_dlgPaletteDialog == NULL) // if doesn't exist, call create
{
m_dlgPaletteDialog = new CPaletteDialog();
ASSERT( m_dlgPaletteDialog != NULL);
if( !m_dlgPaletteDialog->Create(IDD_COLORS_PALETTE)) return;
CRect rectMainFrame, rectPalPos, rectNewPos;
m_dlgPaletteDialog->GetWindowRect( rectPalPos);
GetClientRect( rectMainFrame);
rectNewPos.left = rectMainFrame.right - rectPalPos.Width() - 3;
rectNewPos.right = rectNewPos.left + rectPalPos.Width();
if( m_pInfoFrame == NULL)
{
rectNewPos.top = TOOLS_INIT_TOP;
}
else
{
CRect rectInfo;
m_pInfoFrame->GetWindowRect( rectInfo);
rectNewPos.top = TOOLS_INIT_TOP + rectInfo.Height() + 1;
}
rectNewPos.bottom = rectNewPos.top + rectPalPos.Height();
m_dlgPaletteDialog->MoveWindow( rectNewPos, TRUE);
}
BOOL bVisible = ((m_dlgPaletteDialog->GetStyle() & WS_VISIBLE) != 0);
if( !bVisible) // if dialog isn't visible, show it
{
m_dlgPaletteDialog->ShowWindow(SW_SHOW);
}
else // otherwise, hide it
{
m_dlgPaletteDialog->ShowWindow(SW_HIDE);
}
}
void CMainFrame::OnUpdateViewColorPalette(CCmdUI* pCmdUI)
{
BOOL bVisible;
if( m_dlgPaletteDialog == NULL)
{
bVisible = FALSE;
}
else
{
bVisible = (m_dlgPaletteDialog->GetStyle() & WS_VISIBLE) != 0;
}
pCmdUI->SetCheck( bVisible);
}
BOOL CMainFrame::OnIdle(LONG lCount)
{
// Call OnIdle for animation combo box
m_AnimComboBox.OnIdle( lCount);
// Call OnIdle for texture combo box
m_SkinComboBox.OnIdle( lCount);
// Call OnIdle for color palette dialog
if( m_dlgPaletteDialog != NULL)
{
m_dlgPaletteDialog->OnIdle( lCount);
}
// Call OnIdle for info property sheet
if( m_pInfoFrame != NULL)
{
m_pInfoFrame->m_pInfoSheet->OnIdle( lCount);
}
// Call OnIdle for patches dialog
if( m_dlgPatchesPalette != NULL)
{
m_dlgPatchesPalette->OnIdle( lCount);
}
return TRUE;
}
void CMainFrame::OnFileCreateTexture()
{
CModelerView *pView = (CModelerView *) CModelerView::GetActiveView();
CModelerDoc *pDoc = NULL;
if( pView != NULL)
{
pDoc = pView->GetDocument();
// setup create texture directory
theApp.WriteProfileString(L"Scape", CString(KEY_NAME_CREATE_TEXTURE_DIR),
CString(_fnmApplicationPath+pDoc->GetModelDirectory()));
}
// call create texture dialog
CTFileName fnCreated = _EngineGUI.CreateTexture();
if( (fnCreated != "") && pDoc != NULL)
{
CTextureDataInfo *pNewTDI;
try
{
pNewTDI = pDoc->m_emEditModel.AddTexture_t( fnCreated,
pDoc->m_emEditModel.GetWidth(),
pDoc->m_emEditModel.GetHeight() );
}
catch( char *err_str)
{
AfxMessageBox( CString(err_str));
pNewTDI = NULL;
}
if( pNewTDI != NULL)
{
pDoc->SetModifiedFlag();
pView->m_ptdiTextureDataInfo = pNewTDI;
// switch to texture mode
pView->OnRendUseTexture();
}
}
}
void CMainFrame::DockControlBarRelativeTo(CToolBar* Bar,CToolBar* LeftOf, int dx, int dy)
{
CRect rect;
DWORD dw;
UINT n;
// get MFC to adjust the dimensions of all docked ToolBars
// so that GetWindowRect will be accurate
RecalcLayout();
LeftOf->GetWindowRect(&rect);
rect.OffsetRect(dx, dy);
dw=LeftOf->GetBarStyle();
n = 0;
n = (dw&CBRS_ALIGN_TOP) ? AFX_IDW_DOCKBAR_TOP : n;
n = (dw&CBRS_ALIGN_BOTTOM && n==0) ? AFX_IDW_DOCKBAR_BOTTOM : n;
n = (dw&CBRS_ALIGN_LEFT && n==0) ? AFX_IDW_DOCKBAR_LEFT : n;
n = (dw&CBRS_ALIGN_RIGHT && n==0) ? AFX_IDW_DOCKBAR_RIGHT : n;
// When we take the default parameters on rect, DockControlBar will dock
// each Toolbar on a seperate line. By calculating a rectangle, we in effect
// are simulating a Toolbar being dragged to that location and docked.
DockControlBar(Bar,n,&rect);
}
void CMainFrame::OnViewTexturecontrol()
{
BOOL bVisible = ((m_TextureToolBar.GetStyle() & WS_VISIBLE) != 0);
ShowControlBar(&m_TextureToolBar, !bVisible, FALSE);
RecalcLayout();
}
void CMainFrame::OnUpdateViewTexturecontrol(CCmdUI* pCmdUI)
{
BOOL bVisible = ((m_TextureToolBar.GetStyle() & WS_VISIBLE) != 0);
pCmdUI->SetCheck(bVisible);
}
void CMainFrame::OnViewFxcontrol()
{
BOOL bVisible = ((m_FXToolBar.GetStyle() & WS_VISIBLE) != 0);
ShowControlBar(&m_FXToolBar, !bVisible, FALSE);
RecalcLayout();
}
void CMainFrame::OnUpdateViewFxcontrol(CCmdUI* pCmdUI)
{
BOOL bVisible = ((m_FXToolBar.GetStyle() & WS_VISIBLE) != 0);
pCmdUI->SetCheck(bVisible);
}
void CMainFrame::OnViewStainscontrol()
{
BOOL bVisible = ((m_StainsToolBar.GetStyle() & WS_VISIBLE) != 0);
ShowControlBar(&m_StainsToolBar, !bVisible, FALSE);
RecalcLayout();
}
void CMainFrame::OnUpdateViewStainscontrol(CCmdUI* pCmdUI)
{
BOOL bVisible = ((m_StainsToolBar.GetStyle() & WS_VISIBLE) != 0);
pCmdUI->SetCheck(bVisible);
}
void CMainFrame::OnViewMiplightcontrol()
{
BOOL bVisible = ((m_MipAndLightToolBar.GetStyle() & WS_VISIBLE) != 0);
ShowControlBar(&m_MipAndLightToolBar, !bVisible, FALSE);
RecalcLayout();
}
void CMainFrame::OnUpdateViewMiplightcontrol(CCmdUI* pCmdUI)
{
BOOL bVisible = ((m_MipAndLightToolBar.GetStyle() & WS_VISIBLE) != 0);
pCmdUI->SetCheck(bVisible);
}
void CMainFrame::OnViewScriptcontrol()
{
BOOL bVisible = ((m_ScriptToolBar.GetStyle() & WS_VISIBLE) != 0);
ShowControlBar(&m_ScriptToolBar, !bVisible, FALSE);
RecalcLayout();
}
void CMainFrame::OnUpdateViewScriptcontrol(CCmdUI* pCmdUI)
{
{
BOOL bVisible = ((m_ScriptToolBar.GetStyle() & WS_VISIBLE) != 0);
pCmdUI->SetCheck(bVisible);
}
}
void CMainFrame::OnViewRendercontrol()
{
BOOL bVisible = ((m_RenderControlBar.GetStyle() & WS_VISIBLE) != 0);
ShowControlBar(&m_RenderControlBar, !bVisible, FALSE);
RecalcLayout();
}
void CMainFrame::OnUpdateViewRendercontrol(CCmdUI* pCmdUI)
{
BOOL bVisible = ((m_RenderControlBar.GetStyle() & WS_VISIBLE) != 0);
pCmdUI->SetCheck(bVisible);
}
static BOOL _bSoundEnabled = FALSE;
void CMainFrame::EnableSound(void)
{
if( _bSoundEnabled || !theApp.m_Preferences.ap_bAllowSoundLock) return;
_bSoundEnabled = TRUE;
snd_iFormat = Clamp( snd_iFormat, (INDEX)CSoundLibrary::SF_NONE, (INDEX)CSoundLibrary::SF_44100_16);
_pSound->SetFormat( (enum CSoundLibrary::SoundFormat)snd_iFormat);
}
void CMainFrame::DisableSound(void)
{
//if( !_bSoundEnabled) return;
_bSoundEnabled = FALSE;
_pSound->SetFormat( CSoundLibrary::SF_NONE);
}
void CMainFrame::OnCancelMode()
{
DisableSound();
CMDIFrameWnd::OnCancelMode();
}
void CMainFrame::OnInitMenu(CMenu* pMenu)
{
CMDIFrameWnd::OnInitMenu(pMenu);
}
void CMainFrame::OnStainsAdd()
{
// call file requester for opening documents
CDynamicArray<CTFileName> afnWorkingStains;
_EngineGUI.FileRequester( "Choose textures to add", FILTER_TEX FILTER_END,
"Working textures directory", "Textures\\", "", &afnWorkingStains);
// insert selected textures
FOREACHINDYNAMICARRAY( afnWorkingStains, CTFileName, itStain)
{
// add new working texture
theApp.AddModelerWorkingPatch( itStain.Current());
}
m_StainsComboBox.Refresh();
}
void CMainFrame::OnStainsRemove()
{
CWorkingPatch *pWP = NULL;
int iSelected = m_StainsComboBox.GetCurSel();
if( iSelected != CB_ERR)
{
INDEX iCt = 0;
FOREACHINLIST( CWorkingPatch, wp_ListNode, theApp.m_WorkingPatches, it)
{
if( iCt == iSelected)
{
pWP = &it.Current();
}
iCt ++;
}
}
ASSERT(pWP != NULL);
pWP->wp_ListNode.Remove();
_pTextureStock->Release( pWP->wp_TextureData);
delete pWP;
m_StainsComboBox.Refresh();
}
void CMainFrame::OnUpdateStainsRemove(CCmdUI* pCmdUI)
{
pCmdUI->Enable( !theApp.m_WorkingPatches.IsEmpty());
}
void CMainFrame::OnViewPatchesPalette()
{
if( m_dlgPatchesPalette == NULL) // if doesn't exist, call create
{
m_dlgPatchesPalette = new CPatchPalette();
ASSERT( m_dlgPatchesPalette != NULL);
if( !m_dlgPatchesPalette->Create(IDD_PATCH_PALETTE)) return;
CRect rectMainFrame, rectPalPos, rectNewPos;
m_dlgPatchesPalette->GetWindowRect( rectPalPos);
GetClientRect( rectMainFrame);
rectNewPos.left = rectMainFrame.right - rectPalPos.Width() - 3;
rectNewPos.right = rectNewPos.left + rectPalPos.Width();
rectNewPos.top = TOOLS_INIT_TOP;
if( m_pInfoFrame != NULL)
{
CRect rectInfo;
m_pInfoFrame->GetWindowRect( rectInfo);
rectNewPos.top += rectInfo.Height() + 1;
}
if( m_dlgPaletteDialog != NULL)
{
CRect rectInfo;
m_dlgPaletteDialog->GetWindowRect( rectInfo);
rectNewPos.top += rectInfo.Height() + 1;
}
rectNewPos.bottom = rectNewPos.top + rectPalPos.Height();
m_dlgPatchesPalette->MoveWindow( rectNewPos, TRUE);
}
BOOL bVisible = ((m_dlgPatchesPalette->GetStyle() & WS_VISIBLE) != 0);
if( !bVisible) // if dialog isn't visible, show it
{
m_dlgPatchesPalette->ShowWindow(SW_SHOW);
}
else // otherwise, hide it
{
m_dlgPatchesPalette->ShowWindow(SW_HIDE);
}
}
void CMainFrame::OnViewRotate()
{
BOOL bVisible = ((m_RotateToolBar.GetStyle() & WS_VISIBLE) != 0);
ShowControlBar(&m_RotateToolBar, !bVisible, FALSE);
RecalcLayout();
}
void CMainFrame::OnUpdateViewRotate(CCmdUI* pCmdUI)
{
BOOL bVisible = ((m_RotateToolBar.GetStyle() & WS_VISIBLE) != 0);
pCmdUI->SetCheck(bVisible);
}
void CMainFrame::OnToggleAllBars()
{
ShowControlBar(&m_wndStatusBar, (m_wndStatusBar.GetStyle() & WS_VISIBLE) == 0, FALSE);
ShowControlBar(&m_wndToolBar, (m_wndToolBar.GetStyle() & WS_VISIBLE) == 0, FALSE);
ShowControlBar(&m_AnimToolBar, (m_AnimToolBar.GetStyle() & WS_VISIBLE) == 0, FALSE);
ShowControlBar(&m_TextureToolBar, (m_TextureToolBar.GetStyle() & WS_VISIBLE) == 0, FALSE);
ShowControlBar(&m_StainsToolBar, (m_StainsToolBar.GetStyle() & WS_VISIBLE) == 0, FALSE);
ShowControlBar(&m_ScriptToolBar, (m_ScriptToolBar.GetStyle() & WS_VISIBLE) == 0, FALSE);
ShowControlBar(&m_MipAndLightToolBar, (m_MipAndLightToolBar.GetStyle() & WS_VISIBLE) == 0, FALSE);
ShowControlBar(&m_RenderControlBar, (m_RenderControlBar.GetStyle() & WS_VISIBLE) == 0, FALSE);
ShowControlBar(&m_RotateToolBar, (m_RotateToolBar.GetStyle() & WS_VISIBLE) == 0, FALSE);
ShowControlBar(&m_MappingToolBar, (m_MappingToolBar.GetStyle() & WS_VISIBLE) == 0, FALSE);
ShowControlBar(&m_FXToolBar, (m_FXToolBar.GetStyle() & WS_VISIBLE) == 0, FALSE);
}
void CMainFrame::OnViewMapping()
{
BOOL bVisible = ((m_MappingToolBar.GetStyle() & WS_VISIBLE) != 0);
ShowControlBar(&m_MappingToolBar, !bVisible, FALSE);
RecalcLayout();
}
void CMainFrame::OnUpdateViewMapping(CCmdUI* pCmdUI)
{
BOOL bVisible = ((m_MappingToolBar.GetStyle() & WS_VISIBLE) != 0);
pCmdUI->SetCheck(bVisible);
}
BOOL _bApplicationActive = TRUE;
void CMainFrame::OnActivateApp(BOOL bActive, DWORD hTask)
{
_bApplicationActive = bActive;
CMDIFrameWnd::OnActivateApp(bActive, hTask);
if (!bActive) {
DisableSound();
}
}
BOOL CMainFrame::PreTranslateMessage(MSG* pMsg)
{
BOOL bAltPressed = (GetKeyState( VK_MENU)&0x8000) != 0;
// alt is pressed
BOOL bAlt = FALSE;
if( pMsg->message==WM_LBUTTONDOWN)
{
BOOL bHasDocument = FALSE;
// check for models
POSITION posMdl = theApp.m_pdtModelDocTemplate->GetFirstDocPosition();
while (posMdl!=NULL) {
CModelerDoc *pdocCurrent = (CModelerDoc *)theApp.m_pdtModelDocTemplate->GetNextDoc(posMdl);
bHasDocument = pdocCurrent!=NULL;
}
if( !bHasDocument)
{
// check for scripts
POSITION posScr = theApp.m_pdtScriptTemplate->GetFirstDocPosition();
while (posScr!=NULL) {
CModelerDoc *pdocCurrent = (CModelerDoc *)theApp.m_pdtScriptTemplate->GetNextDoc(posScr);
bHasDocument = pdocCurrent!=NULL;
}
}
BOOL bMainFrameHasFocus = (this == CWnd::GetForegroundWindow());
if( !bHasDocument && bMainFrameHasFocus)
{
static CTimerValue tvLast;
static CPoint ptLast;
CPoint ptNow;
GetCursorPos( &ptNow);
CTimerValue tvNow = _pTimer->GetHighPrecisionTimer();
FLOAT tmDelta = (tvNow-tvLast).GetSeconds();
if( tmDelta<0.5f && abs(ptNow.x-ptLast.x)<5 && abs(ptNow.y-ptLast.y)<5)
{
theApp.OnFileOpen();
}
tvLast=tvNow;
ptLast = ptNow;
}
}
// if we caught alt key message
if( pMsg->message==WM_SYSKEYDOWN)
{
// get key data
int lKeyData = pMsg->lParam;
// test if it is ghost Alt-F4 situation
if( lKeyData & (1L<<29))
{
// Alt key was really pressed
bAlt = TRUE;
}
}
if( (pMsg->message==WM_KEYDOWN) || bAlt)
{
int iVirtKey = (int) pMsg->wParam;
int lKeyData = pMsg->lParam;
if( DYNAMIC_DOWNCAST(CScriptView, GetActiveFrame()->GetActiveView())==NULL)
{
if( (iVirtKey == 'Q') && !bAltPressed)
{
ToggleInfoWindow();
}
}
}
return CMDIFrameWnd::PreTranslateMessage(pMsg);
}
void CMainFrame::ToggleInfoWindow(void)
{
if( m_pInfoFrame == NULL)
{
// create frame for holding info sheet
m_pInfoFrame = new CDlgInfoFrame;
// set initial size of rect window
CRect rectInfoWindow(0, 0, 0, 0);
if( !m_pInfoFrame->Create( NULL, L"Tools info",
MFS_SYNCACTIVE|WS_POPUP|WS_CAPTION|WS_SYSMENU, rectInfoWindow, this))
{
TRACE0("Failed to create Tools info window!\n");
return;
}
}
if (m_pInfoFrame != NULL)
{
if (!m_pInfoFrame->IsWindowVisible())
{
m_pInfoFrame->ShowWindow(SW_SHOW);
m_pInfoFrame->m_pInfoSheet->SetFocus();
CModelerView *pModelerView = CModelerView::GetActiveView();
if( (pModelerView != NULL) && (pModelerView->m_bCollisionMode) )
{
m_pInfoFrame->m_pInfoSheet->CustomSetActivePage(
&m_pInfoFrame->m_pInfoSheet->m_PgInfoCollision);
}
}
else
{
m_pInfoFrame->ShowWindow(SW_HIDE);
}
}
}
void CMainFrame::OnEditSpecular()
{
CDlgCreateSpecularTexture dlgEditSpecular;
dlgEditSpecular.DoModal();
}
void CMainFrame::OnCreateReflectionTexture()
{
CDlgCreateReflectionTexture dlgEditReflection;
dlgEditReflection.DoModal();
}
LRESULT CMainFrame::DefWindowProc(UINT message, WPARAM wParam, LPARAM lParam)
{
if( message==WM_SYSCOMMAND)
{
switch( wParam & ~0x0F)
{
case SC_SCREENSAVE:
case SC_MONITORPOWER:
return 0;
}
}
return CMDIFrameWnd::DefWindowProc(message, wParam, lParam);
}
void CMainFrame::OnHelpFinder()
{
HtmlHelp(NULL); // Hmmm...
/*HtmlHelp(NULL,
_fnmApplicationPath+"Help\\ToolsHelp.chm::/SeriousModeler/Overview.htm",
HH_DISPLAY_TOPIC, NULL);*/
}
void CMainFrame::OnTessellateLess()
{
_pShell->SetINDEX( "gap_bForceTruform", 1); // make sure truform is enabled for all models
INDEX iTruform = _pShell->GetINDEX( "gap_iTruformLevel");
iTruform = Clamp( iTruform-1L, 0L, _pGfx->gl_iMaxTessellationLevel);
_pShell->SetINDEX( "gap_iTruformLevel", iTruform);
CTString strVar;
strVar.PrintF( "Tessellation level = %d", iTruform);
m_wndStatusBar.SetPaneText( STATUS_LINE_PANE, CString(strVar));
}
void CMainFrame::OnTessellateMore()
{
_pShell->SetINDEX( "gap_bForceTruform", 1); // make sure truform is enabled for all models
INDEX iTruform = _pShell->GetINDEX( "gap_iTruformLevel");
iTruform = Clamp( iTruform+1L, 0L, _pGfx->gl_iMaxTessellationLevel);
_pShell->SetINDEX( "gap_iTruformLevel", iTruform);
CTString strVar;
strVar.PrintF( "Tessellation level = %d", iTruform);
m_wndStatusBar.SetPaneText( STATUS_LINE_PANE, CString(strVar));
}