H3cJP/source-engine
1
0
Fork 0
mirror of https://github.com/nillerusr/source-engine.git synced 2024-12-22 06:06:50 +00:00
Code Issues Actions Packages Projects Releases Wiki Activity
master
source-engine/hammer/mainfrm.cpp
FluorescentCIAAfricanAmerican 3bf9df6b27 1
2020-04-22 12:56:21 -04:00

1862 lines
53 KiB
C++
Raw Permalink Blame History

//========= Copyright Valve Corporation, All rights reserved. ============//
//
// Purpose:
//
//=============================================================================//
#include "stdafx.h"
#include <afxadv.h>
#include <oaidl.h>
#include "hammer.h"
#include "Box3D.h" // For units
#include "FaceEditSheet.h"
#include "MainFrm.h"
#include "MessageWnd.h"
#include "ControlBarIDs.h"
#include "CustomMessages.h"
#include "DynamicDialogWnd.h"
#include "filesystem_tools.h"
#include "GlobalFunctions.h"
#include "Prefabs.h"
#include "PrefabsDlg.h"
#include "MapDoc.h"
#include "Manifest.h"
#include "StatusBarIDs.h"
#include "Splash.h"
#include "Options.h"
#include "OptionProperties.h"
#include "ObjectProperties.h"
#include "OP_Groups.h"
#include "MapView2D.h"
#include "MapViewLogical.h"
#include "MapView3D.h"
#include "ChildFrm.h"
#include "NewDocType.h"
#include "SearchReplaceDlg.h"
#include "TextureBrowser.h"
#include "TextureSystem.h"
#include "ToolManager.h"
#include "Material.h"
#include "materialsystem/imaterialsystem.h"
#include "materialsystem/MaterialSystem_Config.h"
#include "soundbrowser.h"
#include "lprvwindow.h"
// memdbgon must be the last include file in a .cpp file!!!
#include <tier0/memdbgon.h>
IMPLEMENT_DYNAMIC(CMainFrame, CMDIFrameWnd)
BEGIN_MESSAGE_MAP(CMainFrame, CMDIFrameWnd)
//{{AFX_MSG_MAP(CMainFrame)
ON_WM_CREATE()
ON_COMMAND(ID_EDIT_PROPERTIES, OnEditProperties)
ON_UPDATE_COMMAND_UI(ID_EDIT_PROPERTIES, OnUpdateEditFunction)
ON_COMMAND(ID_VIEW_MESSAGES, OnViewMessages)
ON_UPDATE_COMMAND_UI(ID_VIEW_MESSAGES, OnUpdateViewMessages)
ON_WM_ACTIVATEAPP()
ON_WM_SIZE()
ON_WM_CLOSE()
ON_WM_DESTROY()
ON_WM_PAINT()
ON_WM_TIMER()
ON_COMMAND(ID_TOOLS_OPTIONS, OnToolsOptions)
ON_COMMAND(ID_TOOLS_PREFABFACTORY, OnToolsPrefabfactory)
ON_COMMAND_EX(ID_HELP_TOPICS, OnHelpOpenURL)
ON_COMMAND_EX(ID_HELP_EDITINGSITE, OnHelpOpenURL)
ON_COMMAND_EX(ID_HELP_WORLDCRAFT_SUPPORT_MAIL, OnHelpOpenURL)
ON_COMMAND(ID_EDIT_UNDOREDOACTIVE, OnEditUndoredoactive)
ON_UPDATE_COMMAND_UI(ID_EDIT_UNDOREDOACTIVE, OnUpdateEditUndoredoactive)
ON_COMMAND_EX(ID_FILE_NEW, OnFileNew)
ON_COMMAND(ID_SAVEWINDOWSTATE, OnSavewindowstate)
ON_COMMAND(ID_LOADWINDOWSTATE, OnLoadwindowstate)
ON_COMMAND_EX(ID_MAP_UNITS_NONE, OnUnits)
ON_UPDATE_COMMAND_UI(ID_MAP_UNITS_NONE, OnUpdateUnits)
ON_COMMAND_EX(ID_MAP_UNITS_INCHES, OnUnits)
ON_UPDATE_COMMAND_UI(ID_MAP_UNITS_INCHES, OnUpdateUnits)
ON_COMMAND_EX(ID_MAP_UNITS_FEET_INCHES, OnUnits)
ON_UPDATE_COMMAND_UI(ID_MAP_UNITS_FEET_INCHES, OnUpdateUnits)
ON_UPDATE_COMMAND_UI(ID_VIEW_OPAQUE_MATERIALS, OnUpdateOpaqueMaterials)
ON_UPDATE_COMMAND_UI(ID_VIEW_2DXZ, OnUpdateView2d)
ON_UPDATE_COMMAND_UI(ID_VIEW_2DYZ, OnUpdateView2d)
ON_UPDATE_COMMAND_UI(ID_VIEW_2DXY, OnUpdateView2d)
ON_UPDATE_COMMAND_UI(ID_VIEW_3DWIREFRAME, OnUpdateView3d)
ON_UPDATE_COMMAND_UI(ID_VIEW_3DPOLYGON, OnUpdateView3d)
ON_UPDATE_COMMAND_UI(ID_VIEW_3DTEXTURED, OnUpdateView3d)
//ON_UPDATE_COMMAND_UI(ID_VIEW_3DENGINE, OnUpdateView3d)
ON_COMMAND(ID_VIEW_OPAQUE_MATERIALS, OnOpaqueMaterials)
ON_COMMAND_EX(ID_VIEW3D_BRIGHTER, OnView3dChangeBrightness)
ON_COMMAND_EX(ID_VIEW3D_DARKER, OnView3dChangeBrightness)
ON_UPDATE_COMMAND_UI(ID_VIEW_OBJECTBAR, CFrameWnd::OnUpdateControlBarMenu)
ON_COMMAND_EX(ID_VIEW_OBJECTBAR, CFrameWnd::OnBarCheck)
ON_UPDATE_COMMAND_UI(ID_VIEW_SELECTION_MODE_BAR, CFrameWnd::OnUpdateControlBarMenu)
ON_COMMAND_EX(ID_VIEW_SELECTION_MODE_BAR, CFrameWnd::OnBarCheck)
ON_UPDATE_COMMAND_UI(ID_VIEW_FILTERCONTROL, CFrameWnd::OnUpdateControlBarMenu)
ON_COMMAND_EX(ID_VIEW_FILTERCONTROL, CFrameWnd::OnBarCheck)
ON_UPDATE_COMMAND_UI(ID_VIEW_MAPVIEWBAR, CFrameWnd::OnUpdateControlBarMenu)
ON_COMMAND_EX(ID_VIEW_MAPVIEWBAR, CFrameWnd::OnBarCheck)
ON_UPDATE_COMMAND_UI(ID_VIEW_MAPTOOLSBAR, CFrameWnd::OnUpdateControlBarMenu)
ON_COMMAND_EX(ID_VIEW_MAPTOOLSBAR, CFrameWnd::OnBarCheck)
ON_UPDATE_COMMAND_UI(ID_VIEW_TEXTUREBAR, CFrameWnd::OnUpdateControlBarMenu)
ON_COMMAND_EX(ID_VIEW_TEXTUREBAR, CFrameWnd::OnBarCheck)
ON_UPDATE_COMMAND_UI(ID_VIEW_MANIFEST_BAR, CFrameWnd::OnUpdateControlBarMenu)
ON_COMMAND_EX(ID_VIEW_MANIFEST_BAR, CFrameWnd::OnBarCheck)
//ON_UPDATE_COMMAND_UI(ID_VIEW_ANIMATIONBAR, CFrameWnd::OnUpdateControlBarMenu)
//ON_COMMAND_EX(ID_VIEW_ANIMATIONBAR, CFrameWnd::OnBarCheck)
ON_UPDATE_COMMAND_UI(ID_VIEW_MAPOPSBAR, CFrameWnd::OnUpdateControlBarMenu)
ON_COMMAND_EX(ID_VIEW_MAPOPSBAR, CFrameWnd::OnBarCheck)
ON_COMMAND_EX(ID_TOOLS_POINTER, OnChangeTool)
ON_UPDATE_COMMAND_UI(ID_TOOLS_POINTER, OnUpdateToolUI)
ON_COMMAND_EX(ID_TOOLS_CAMERA, OnChangeTool)
ON_UPDATE_COMMAND_UI(ID_TOOLS_CAMERA, OnUpdateToolUI)
ON_COMMAND_EX(ID_TOOLS_MAGNIFY, OnChangeTool)
ON_UPDATE_COMMAND_UI(ID_TOOLS_MAGNIFY, OnUpdateToolUI)
ON_COMMAND_EX(ID_TOOLS_BLOCK, OnChangeTool)
ON_UPDATE_COMMAND_UI(ID_TOOLS_BLOCK, OnUpdateToolUI)
ON_COMMAND_EX(ID_TOOLS_ENTITY, OnChangeTool)
ON_UPDATE_COMMAND_UI(ID_TOOLS_ENTITY, OnUpdateToolUI)
ON_COMMAND_EX(ID_TOOLS_APPLYDECALS, OnChangeTool)
ON_UPDATE_COMMAND_UI(ID_TOOLS_APPLYDECALS, OnUpdateToolUI)
ON_COMMAND_EX(ID_TOOLS_MORPH, OnChangeTool)
ON_UPDATE_COMMAND_UI(ID_TOOLS_MORPH, OnUpdateToolUI)
ON_COMMAND_EX(ID_TOOLS_CLIPPER, OnChangeTool)
ON_UPDATE_COMMAND_UI(ID_TOOLS_CLIPPER, OnUpdateToolUI)
ON_COMMAND_EX(ID_TOOLS_EDITCORDON, OnChangeTool)
ON_UPDATE_COMMAND_UI(ID_TOOLS_EDITCORDON, OnUpdateToolUI)
ON_COMMAND_EX(ID_TOOLS_PATH, OnChangeTool)
ON_UPDATE_COMMAND_UI(ID_TOOLS_PATH, OnUpdateToolUI)
ON_COMMAND_EX(ID_TOOLS_OVERLAY, OnChangeTool)
ON_UPDATE_COMMAND_UI(ID_TOOLS_OVERLAY, OnUpdateToolUI)
ON_COMMAND_EX(ID_MODE_APPLICATOR, OnApplicator)
ON_COMMAND_EX(ID_TOOLS_SOUND_BROWSER, OnSoundBrowser)
ON_COMMAND_EX(ID_FILE_RELOAD_SOUNDS, OnReloadSounds)
ON_UPDATE_COMMAND_UI(ID_MODE_APPLICATOR, OnUpdateApplicatorUI)
ON_COMMAND(ID_HELP_FINDER, CMDIFrameWnd::OnHelpFinder)
ON_COMMAND(ID_HELP, CMDIFrameWnd::OnHelp)
ON_COMMAND(ID_CONTEXT_HELP, CMDIFrameWnd::OnContextHelp)
ON_COMMAND(ID_DEFAULT_HELP, CMDIFrameWnd::OnHelpFinder)
ON_COMMAND(ID_HDR, OnHDR)
ON_WM_HELPINFO()
ON_WM_SYSCOMMAND()
ON_WM_ENTERMENULOOP()
//}}AFX_MSG_MAP
END_MESSAGE_MAP()
static UINT indicators[] =
{
ID_SEPARATOR, // status line indicator
ID_INDICATOR_SELECTION,
ID_INDICATOR_COORDS,
ID_INDICATOR_SIZE,
ID_INDICATOR_GRIDZOOM,
ID_INDICATOR_SNAP
};
const int NUMSTATUSPANES = 7;
const char * WINSTATETAG = "WCWINSTATE";
const int WINSTATEEND = -1;
const int WINSTATE2DVIEW = 0;
const int WINSTATE3DVIEW = 1;
const int WINSTATELOGICALVIEW = 2;
const float fVersion = 0.1f;
struct
{
int nIndex;
UINT nID;
UINT nStyle;
int cxWidth;
} paneinfo[NUMSTATUSPANES] =
{
{ SBI_PROMPT, ID_SEPARATOR, SBPS_STRETCH | SBPS_NOBORDERS, 0 },
{ SBI_SELECTION, ID_INDICATOR_SELECTION, SBPS_NORMAL, 300 },
{ SBI_COORDS, ID_INDICATOR_COORDS, SBPS_NORMAL, 100 },
{ SBI_SIZE, ID_INDICATOR_SIZE, SBPS_NORMAL, 180 },
{ SBI_GRIDZOOM, ID_INDICATOR_GRIDZOOM, SBPS_NORMAL, 80 },
{ SBI_SNAP, ID_INDICATOR_SNAP, SBPS_NORMAL, 135 },
{ SBI_LIGHTPROGRESS,ID_INDICATOR_LIGHTPROGRESS, SBPS_NORMAL, 50 }
};
static GameData gd;
static CMainFrame *pMainWnd;
//-----------------------------------------------------------------------------
// Purpose: Constructor.
//-----------------------------------------------------------------------------
CMainFrame::CMainFrame(void)
{
pTextureBrowser = NULL;
pObjectProperties = NULL;
m_bUndoActive = TRUE;
m_bShellSessionActive = false;
m_pFaceEditSheet = NULL;
m_bMinimized = false;
m_pSearchReplaceDlg = NULL;
m_pLightingPreviewOutputWindow = NULL;
m_bLightingPreviewOutputWindowShowing = false;
}
//-----------------------------------------------------------------------------
// Purpose: Destructor.
//-----------------------------------------------------------------------------
CMainFrame::~CMainFrame(void)
{
delete pObjectProperties;
delete pTextureBrowser;
delete m_pFaceEditSheet;
delete m_pSearchReplaceDlg;
delete m_pLightingPreviewOutputWindow;
CPrefabLibrary::FreeAllLibraries();
}
//-----------------------------------------------------------------------------
// Purpose: Called through the shell to begin a session of editing the map
// via the shell. The user interface is disabled to prevent a mismatched
// versions between Hammer and the shell client.
//-----------------------------------------------------------------------------
void CMainFrame::BeginShellSession(void)
{
m_bShellSessionActive = true;
}
//-----------------------------------------------------------------------------
// Purpose: Called through the shell to end a session of editing the map
// via the engine. The user interface is enabled.
//-----------------------------------------------------------------------------
void CMainFrame::EndShellSession(void)
{
m_bShellSessionActive = false;
}
//-----------------------------------------------------------------------------
// Purpose: If we get here there is no active 3D view. Uncheck the button.
//-----------------------------------------------------------------------------
void CMainFrame::OnUpdateView3d(CCmdUI *pCmdUI)
{
pCmdUI->SetCheck(FALSE);
}
//-----------------------------------------------------------------------------
// Purpose: If we get here there is no active 3D view. Uncheck the button.
//-----------------------------------------------------------------------------
void CMainFrame::OnUpdateOpaqueMaterials(CCmdUI *pCmdUI)
{
pCmdUI->SetCheck(MaterialSystemConfig().bNoTransparency);
}
void CMainFrame::OnOpaqueMaterials()
{
MaterialSystemConfig().bNoTransparency = !MaterialSystemConfig().bNoTransparency;
MaterialSystemInterface()->OverrideConfig( MaterialSystemConfig(), false );
}
//-----------------------------------------------------------------------------
// Purpose: If we get here there is no active 2D view. Uncheck the button.
//-----------------------------------------------------------------------------
void CMainFrame::OnUpdateView2d(CCmdUI *pCmdUI)
{
pCmdUI->SetCheck(FALSE);
}
void CMainFrame::OnEnterMenuLoop( BOOL bIsTrackPopupMenu )
{
CMapDoc *pDoc = CMapDoc::GetActiveMapDoc();
// if we are translation objects with a tool right now, dont switch to Menu mode
if ( pDoc )
{
CBaseTool *pTool = pDoc->GetTools()->GetActiveTool();
if ( pTool && pTool->IsTranslating() )
{
SendMessage( WM_CANCELMODE );
}
}
}
//-----------------------------------------------------------------------------
// Purpose:
// Input : lpCreateStruct -
// Output :
//-----------------------------------------------------------------------------
int CMainFrame::OnCreate(LPCREATESTRUCT lpCreateStruct)
{
const DWORD dwDefStyles = WS_CHILD | WS_VISIBLE | CBRS_TOP;
lpCreateStruct->lpszClass = "VALVEWORLDCRAFT";
if (CMDIFrameWnd::OnCreate(lpCreateStruct) == -1)
return -1;
if(!wndMDIClient.SubclassWindow(m_hWndMDIClient))
{
TRACE ("Failed to subclass MDI client window\n");
return (-1);
}
//
// Map view toolbar.
//
if (!m_wndMapToolBar.Create(this, dwDefStyles, IDCB_MAPVIEWBAR) || !m_wndMapToolBar.LoadToolBar(IDR_MAPDOC_VALVE))
{
TRACE0("Failed to create toolbar\n");
return -1; // fail to create
}
m_wndMapToolBar.ModifyStyle(0, TBSTYLE_FLAT);
//
// Undo redo toolbar.
//
if (!m_wndUndoRedoToolBar.Create(this, dwDefStyles, IDCB_UNDO_REDO_BAR) || !m_wndUndoRedoToolBar.LoadToolBar(IDR_UNDOREDO))
{
TRACE0("Failed to create toolbar\n");
return -1; // fail to create
}
m_wndUndoRedoToolBar.ModifyStyle(0, TBSTYLE_FLAT);
//
// Map editing toolbar.
//
m_wndMapEditToolBar.Create(this, dwDefStyles, IDCB_MAPTOOLSBAR);
m_wndMapEditToolBar.ModifyStyle(0, TBSTYLE_FLAT);
m_wndMapEditToolBar.LoadToolBar(IDR_MAPEDITTOOLS_VALVE);
m_bmMapEditTools256.LoadBitmap(IDB_MAPEDITTOOLS_256);
m_wndMapEditToolBar.SetBitmap((HBITMAP)m_bmMapEditTools256);
//
// Map operations toolbar.
//
if (!m_wndMapOps.Create(this, dwDefStyles, IDCB_MAPOPERATIONS) || !m_wndMapOps.LoadToolBar(IDR_MAPOPERATIONS_VALVE))
{
TRACE0("Failed to create toolbar\n");
return -1; // fail to create
}
m_wndMapOps.ModifyStyle(0, TBSTYLE_FLAT);
//
// Status bar.
//
if (!m_wndStatusBar.Create(this) || !m_wndStatusBar.SetIndicators(NULL, NUMSTATUSPANES))
{
TRACE0("Failed to create status bar\n");
return -1; // fail to create
}
for(int i = 0; i < NUMSTATUSPANES; i++)
{
m_wndStatusBar.SetPaneInfo(paneinfo[i].nIndex, paneinfo[i].nID, paneinfo[i].nStyle, paneinfo[i].cxWidth);
}
EnableDocking(CBRS_ALIGN_ANY);
m_wndMapToolBar.SetBarStyle(m_wndMapToolBar.GetBarStyle() |
CBRS_TOOLTIPS | CBRS_FLYBY | CBRS_SIZE_DYNAMIC);
m_wndUndoRedoToolBar.SetBarStyle(m_wndUndoRedoToolBar.GetBarStyle() |
CBRS_TOOLTIPS | CBRS_FLYBY | CBRS_SIZE_DYNAMIC);
m_wndMapEditToolBar.SetBarStyle(m_wndMapEditToolBar.GetBarStyle() |
CBRS_TOOLTIPS | CBRS_FLYBY | CBRS_SIZE_DYNAMIC);
m_wndMapOps.SetBarStyle(m_wndMapOps.GetBarStyle() |
CBRS_TOOLTIPS | CBRS_FLYBY | CBRS_SIZE_DYNAMIC);
m_wndMapToolBar.EnableDocking(CBRS_ALIGN_ANY);
m_wndUndoRedoToolBar.EnableDocking(CBRS_ALIGN_ANY);
m_wndMapEditToolBar.EnableDocking(CBRS_ALIGN_ANY);
m_wndMapOps.EnableDocking(CBRS_ALIGN_ANY);
DockControlBar(&m_wndMapEditToolBar, AFX_IDW_DOCKBAR_LEFT);
// top bars
DockControlBar(&m_wndMapToolBar, AFX_IDW_DOCKBAR_TOP);
DockControlBarLeftOf(&m_wndUndoRedoToolBar, &m_wndMapToolBar );
DockControlBarLeftOf(&m_wndMapOps, &m_wndUndoRedoToolBar);
// rightside control bars
m_ObjectBar.Create(this);
m_ObjectBar.SetBarStyle(m_ObjectBar.GetBarStyle() |
CBRS_TOOLTIPS | CBRS_FLYBY | CBRS_SIZE_FIXED);
m_ObjectBar.EnableDocking(CBRS_ALIGN_LEFT | CBRS_ALIGN_RIGHT);
DockControlBar(&m_ObjectBar, AFX_IDW_DOCKBAR_RIGHT);
m_FilterControl.Create(this);
m_FilterControl.SetBarStyle(m_FilterControl.GetBarStyle() |
CBRS_TOOLTIPS | CBRS_FLYBY | CBRS_SIZE_FIXED);
m_FilterControl.EnableDocking(CBRS_ALIGN_LEFT | CBRS_ALIGN_RIGHT);
DockControlBarLeftOf(&m_FilterControl, &m_ObjectBar);
m_TextureBar.Create(this);
m_TextureBar.SetBarStyle(m_TextureBar.GetBarStyle() |
CBRS_TOOLTIPS | CBRS_FLYBY | CBRS_SIZE_FIXED);
m_TextureBar.EnableDocking(CBRS_ALIGN_LEFT | CBRS_ALIGN_RIGHT);
DockControlBarLeftOf(&m_TextureBar, &m_FilterControl);
m_ManifestFilterControl.Create(this);
m_ManifestFilterControl.SetBarStyle(m_ManifestFilterControl.GetBarStyle() |
CBRS_TOOLTIPS | CBRS_FLYBY | CBRS_SIZE_FIXED);
m_ManifestFilterControl.EnableDocking(CBRS_ALIGN_LEFT | CBRS_ALIGN_RIGHT);
DockControlBar(&m_ManifestFilterControl, AFX_IDW_DOCKBAR_RIGHT);
m_pFaceEditSheet = new CFaceEditSheet( "Face Edit Sheet", this );
m_pFaceEditSheet->Setup();
m_pFaceEditSheet->Create( this );
m_pFaceEditSheet->SetVisibility( false );
m_pLightingPreviewOutputWindow = NULL;
//
// Create the animation dialog bar.
//
//m_AnimationDlg.Create(this);
//m_AnimationDlg.SetBarStyle(m_TextureBar.GetBarStyle() | CBRS_TOOLTIPS | CBRS_FLYBY | CBRS_SIZE_FIXED);
//m_AnimationDlg.EnableDocking(CBRS_ALIGN_LEFT | CBRS_ALIGN_RIGHT);
//DockControlBarLeftOf(&m_AnimationDlg, &m_TextureBar);
//
// Create the selection mode dialog bar.
//
m_SelectModeDlg.Create(this);
m_SelectModeDlg.SetBarStyle(m_TextureBar.GetBarStyle() | CBRS_TOOLTIPS | CBRS_FLYBY | CBRS_SIZE_FIXED);
m_SelectModeDlg.EnableDocking(CBRS_ALIGN_LEFT | CBRS_ALIGN_RIGHT);
DockControlBarLeftOf(&m_SelectModeDlg, &m_TextureBar);
//
// Create object properties sheet - not visible yet.
//
pObjectProperties = new CObjectProperties;
pObjectProperties->SetupPages();
pObjectProperties->Create(this, WS_SYSMENU | WS_POPUP | WS_CAPTION | DS_MODALFRAME | WS_THICKFRAME);
pMainWnd = this;
//
// Create the smoothing group visualization dialog.
//
m_SmoothingGroupDlg.Create( IDD_SMOOTHING_GROUP_VISUAL, this );
//
// Create message window.
//
CRect clientrect;
wndMDIClient.GetClientRect(clientrect);
g_pwndMessage->CreateMessageWindow( this, CRect( 0, clientrect.Height() - 90, clientrect.Width(), clientrect.Height() ) );
CPrefabLibrary::LoadAllLibraries();
ToolManager()->SetTool(TOOL_POINTER);
pTextureBrowser = new CTextureBrowser(this);
// HACK: Spackle up the maximized window position to (0, 0) to fix an intermittent bug. =(
WINDOWPLACEMENT wp;
ZeroMemory(&wp, sizeof(wp));
wp.length = sizeof(wp);
SetWindowPlacement(&wp);
//
// !!!NOTE: Always do this last to ensure that the layout does not get recalculated before the
// window is maximized. This prevents control bars from being incorrectly wrapped to
// the next column.
//
if (VerifyBarState())
{
LoadBarState("Barstate");
}
return 0;
}
void CMainFrame::DockControlBarLeftOf(CControlBar* Bar, CControlBar* LeftOf)
{
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(1,0);
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);
}
BOOL CMainFrame::PreCreateWindow(CREATESTRUCT& cs)
{
cs.style |= WS_MAXIMIZE;
cs.lpszClass = "VALVEWORLDCRAFT";
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
//-----------------------------------------------------------------------------
// Purpose: Maps menu IDs to tool IDs.
// Input : uMsg - Menu ID from a WM_COMMAND message.
//-----------------------------------------------------------------------------
static ToolID_t _ToolMsgToEnum(UINT uMsg)
{
struct ToolIDMap_t
{
UINT uMsg;
ToolID_t eToolID;
};
ToolIDMap_t nIDMap[] =
{
{ ID_TOOLS_POINTER, TOOL_POINTER },
{ ID_TOOLS_BLOCK, TOOL_BLOCK },
{ ID_TOOLS_ENTITY, TOOL_ENTITY },
{ ID_TOOLS_CAMERA, TOOL_CAMERA },
{ ID_TOOLS_MAGNIFY, TOOL_MAGNIFY },
{ ID_TOOLS_MORPH, TOOL_MORPH },
{ ID_TOOLS_CLIPPER, TOOL_CLIPPER },
{ ID_TOOLS_EDITCORDON, TOOL_EDITCORDON },
{ ID_TOOLS_OVERLAY, TOOL_OVERLAY },
{ ID_TOOLS_APPLYDECALS, TOOL_DECAL },
{ ID_MODE_APPLICATOR, TOOL_FACEEDIT_MATERIAL },
};
for (int i = 0; i < sizeof(nIDMap) / sizeof(nIDMap[0]); i++)
{
if (uMsg == nIDMap[i].uMsg)
{
return nIDMap[i].eToolID;
}
}
return TOOL_POINTER;
}
//-----------------------------------------------------------------------------
// Purpose: activates the current tool toolbar button
// Input : pUI - interface to button that has had a action happen
//-----------------------------------------------------------------------------
void CMainFrame::OnUpdateToolUI(CCmdUI *pUI)
{
if (IsShellSessionActive())
{
pUI->Enable(FALSE);
}
else
{
//
// check for button enabling
//
CMapDoc *pDoc = CMapDoc::GetActiveMapDoc();
bool bIsEditable = ( pDoc ? pDoc->IsSelectionEditable() : false );
if ( pUI->m_nID == ID_TOOLS_APPLYDECALS ||
pUI->m_nID == ID_TOOLS_OVERLAY ||
pUI->m_nID == ID_TOOLS_CLIPPER ||
pUI->m_nID == ID_TOOLS_MORPH )
{
}
else
{
bIsEditable = ( pDoc ? true : false );
}
#if 0
//
// Only enable the displacement toolbar button while editing HalfLife 2 maps.
//
if ( pUI->m_nID == ID_TOOLS_DISPLACE )
{
if ( pDoc != NULL )
{
pUI->Enable(pDoc->GetMapFormat() == mfHalfLife2);
}
else
{
pUI->Enable( pDoc != NULL );
}
}
else
#endif
{
pUI->Enable( bIsEditable );
}
ToolID_t eToolID = _ToolMsgToEnum(pUI->m_nID);
pUI->Enable( bIsEditable );
pUI->SetCheck(eToolID == ToolManager()->GetActiveToolID());
}
}
//-----------------------------------------------------------------------------
// Purpose: Handles toolbar and menu messages that change the active tool.
// Input : nMessageID - the id of the menu item
// Output : Returns TRUE to indicate that the message was handled.
//-----------------------------------------------------------------------------
BOOL CMainFrame::OnChangeTool(UINT nMessageID)
{
//
// Changing tool -- exit face edit mode if necessary.
// This is here because face edit mode encompasses two tools: the
// material tool and the displacement tool. Which tool we use is set
// by the OnSetActive handler of each page of the face edit sheet.
//
if (IsInFaceEditMode())
{
EnableFaceEditMode(false);
}
//
// Activate the new tool.
//
ToolID_t eToolID = _ToolMsgToEnum(nMessageID);
ToolManager()->SetTool(eToolID);
return TRUE;
}
//-----------------------------------------------------------------------------
// Purpose: Brings up the
//-----------------------------------------------------------------------------
void CMainFrame::OnViewMessages(void)
{
g_pwndMessage->ToggleMessageWindow();
}
//-----------------------------------------------------------------------------
// Purpose: Manages the state of the view messages menu item.
//-----------------------------------------------------------------------------
void CMainFrame::OnUpdateViewMessages(CCmdUI *pCmdUI)
{
pCmdUI->SetCheck( g_pwndMessage->IsVisible() );
}
//-----------------------------------------------------------------------------
// Purpose: Brings up the Object Properties dialog.
//-----------------------------------------------------------------------------
void CMainFrame::OnEditProperties(void)
{
pObjectProperties->ShowWindow(pObjectProperties->IsWindowVisible() ? SW_HIDE : SW_SHOW);
}
//-----------------------------------------------------------------------------
// Purpose: Tell all the documents to redraw all their views.
//-----------------------------------------------------------------------------
void CMainFrame::UpdateAllDocViews(DWORD dwCmd)
{
for ( int i=0; i<CMapDoc::GetDocumentCount(); i++ )
{
CMapDoc *pDoc = CMapDoc::GetDocument(i);
if (pDoc->GetGame() != NULL)
{
pDoc->UpdateAllViews( dwCmd );
}
}
if (dwCmd & MAPVIEW_UPDATE_VISGROUP_ALL)
{
// This updates everything, so it takes priority.
m_FilterControl.UpdateGroupList();
}
else if (dwCmd & MAPVIEW_UPDATE_VISGROUP_STATE)
{
// Only update the hidden/shown state of the visgroups.
m_FilterControl.UpdateGroupListChecks();
}
}
//-----------------------------------------------------------------------------
// Purpose: Informs our application object when we are activated or deactivated.
// Input : bActive - TRUE to activate, FALSE to deactivate.
// hTask - task becoming active.
//-----------------------------------------------------------------------------
#if _MSC_VER < 1300
void CMainFrame::OnActivateApp(BOOL bActive, HTASK hTask)
#else
void CMainFrame::OnActivateApp(BOOL bActive, DWORD hTask)
#endif
{
CMDIFrameWnd::OnActivateApp(bActive, hTask);
// Had to change this code to not call GetWindowPlacement because for some reason
// that prevented Hammer from maximizing properly -- it would leave space on top.
// So I cache the minimized state instead, which fixes the problem. Sigh.
if (!m_bMinimized)
{
MaterialSystemInterface()->EvictManagedResources();
APP()->OnActivateApp(bActive == TRUE);
}
}
//-----------------------------------------------------------------------------
// Purpose:
// Input : nID -
// lParam -
//-----------------------------------------------------------------------------
void CMainFrame::OnSysCommand(UINT nID, LPARAM lParam)
{
CMDIFrameWnd::OnSysCommand(nID, lParam);
if (nID == SC_MINIMIZE)
{
m_bMinimized = true;
APP()->OnActivateApp(false);
}
else if ((nID == SC_MAXIMIZE) || (nID == SC_RESTORE))
{
m_bMinimized = false;
APP()->OnActivateApp(true);
}
}
//-----------------------------------------------------------------------------
// Purpose: Called when the active document is deleted.
//-----------------------------------------------------------------------------
void CMainFrame::OnDeleteActiveDocument(void)
{
pObjectProperties->MarkDataDirty();
}
//-----------------------------------------------------------------------------
// Purpose: Handles resize messages. Resizes any children that depend on our size.
// Input : nType -
// cx -
// cy -
//-----------------------------------------------------------------------------
void CMainFrame::OnSize(UINT nType, int cx, int cy)
{
CMDIFrameWnd::OnSize(nType, cx, cy);
//
// Resize the message window if it exists.
//
if ( g_pwndMessage != NULL )
{
CRect clientrect;
wndMDIClient.GetClientRect(clientrect);
g_pwndMessage->Resize(CRect(0, clientrect.Height() - 130, clientrect.Width(), clientrect.Height()));
}
}
//-----------------------------------------------------------------------------
// Purpose: Returns a pointer to the main frame window.
//-----------------------------------------------------------------------------
CMainFrame *GetMainWnd(void)
{
return pMainWnd;
}
//-----------------------------------------------------------------------------
// Purpose:
// Input : nIndex -
// pszText -
//-----------------------------------------------------------------------------
void SetStatusText(int nIndex, LPCTSTR pszText)
{
GetMainWnd()->GetStatusBar()->SetPaneText(nIndex, pszText);
}
//-----------------------------------------------------------------------------
// Purpose: Invokes the configuration dialog, saving the options if the user
// hits the OK button.
//-----------------------------------------------------------------------------
void CMainFrame::Configure(void)
{
COptionProperties dlg("Configure Hammer", NULL, 0);
if (dlg.DoModal() == IDOK)
{
Options.Write( TRUE, TRUE );
}
}
//-----------------------------------------------------------------------------
// Purpose: Invokes the configuration dialog.
//-----------------------------------------------------------------------------
void CMainFrame::OnToolsOptions(void)
{
Configure();
}
//-----------------------------------------------------------------------------
// Purpose: Called when the main frame is closing. Cleans up the dialog bars
// and saves the options to the registry.
//-----------------------------------------------------------------------------
void CMainFrame::OnClose()
{
// Copied from CFrameWnd::OnClose. We can't call APP()->BeginClosing if they
// hit cancel in the Save Modified dialog, and CFrameWnd::OnClose doesn't have
// a return code to let us know if we're actually closing. Preposterous.
// Note: only queries the active document
CDocument *pDocument = GetActiveDocument();
if (pDocument != NULL && !pDocument->CanCloseFrame(this))
{
// document can't close right now -- don't close it
return;
}
//
// Save the splitter configuration of the first child window in our list.
//
CChildFrame *pChild = GetNextMDIChildWnd(NULL);
if (pChild != NULL)
{
pChild->SaveOptions();
}
CWinApp *pApp = AfxGetApp();
if (pApp != NULL && pApp->m_pMainWnd == this)
{
// attempt to save all documents
if (pDocument == NULL && !pApp->SaveAllModified())
{
// don't close it
return;
}
pApp->CloseAllDocuments( FALSE );
}
// End of copied stuff.
APP()->BeginClosing();
// want to save the faceeditor as hidden
ShowFaceEditSheetOrTextureBar( false );
SaveBarState("Barstate");
//AfxGetApp()->WriteProfileInt("General", "NewBars", TRUE);
// Remove the smoothing group dialog window.
m_SmoothingGroupDlg.DestroyWindow();
// save options
Options.general.bClosedCorrectly = TRUE;
Options.Write( TRUE, TRUE );
CMDIFrameWnd::OnClose();
}
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
void CMainFrame::OnDestroy(void)
{
CMDIFrameWnd::OnDestroy();
PostQuitMessage(-1);
}
//-----------------------------------------------------------------------------
// Purpose: Sets a timer for destroying the splash screen.
//-----------------------------------------------------------------------------
void CMainFrame::OnPaint(void)
{
static bool bFirst = true;
CPaintDC dc(this); // device context for painting
if (bFirst)
{
bFirst = false;
SetTimer(FIRST_TIMER, 500, NULL);
}
}
//-----------------------------------------------------------------------------
// Purpose: This is called ONCE when the splash wnd is to be destroyed. OnPaint()
// sets the timer. This is now also called for the autosave timer.
// Input : nIDEvent -
//-----------------------------------------------------------------------------
void CMainFrame::OnTimer(UINT nIDEvent)
{
if (!::IsWindow(m_hWnd))
{
return;
}
if( nIDEvent == AUTOSAVE_TIMER )
{
APP()->Autosave();
}
if( nIDEvent == FIRST_TIMER ) //for the splash scren window destruction
{
// only want it once
KillTimer(nIDEvent);
// Don't continue if Hammer isn't configured yet!
if (Options.configs.nConfigs == 0)
return;
Options.SetClosedCorrectly( FALSE );
SetBrightness(Options.textures.fBrightness);
// repaint texture window
m_TextureBar.Invalidate();
//when hammer is ready, start the autosave timer.
if ( Options.general.iMaxAutosavesPerMap != 0 )
{
SetTimer( AUTOSAVE_TIMER, Options.general.iTimeBetweenSaves * 60 * 1000, NULL );
}
}
}
//-----------------------------------------------------------------------------
// Purpose: Called when timer value is changed in the options
// Input : void
//-----------------------------------------------------------------------------
void CMainFrame::ResetAutosaveTimer( void )
{
if ( Options.general.iMaxAutosavesPerMap != 0 )
{
SetTimer( AUTOSAVE_TIMER, Options.general.iTimeBetweenSaves * 60 * 1000, NULL );
}
else
{
KillTimer( AUTOSAVE_TIMER );
}
}
//-----------------------------------------------------------------------------
// Purpose:
// Input : fBrightness -
//-----------------------------------------------------------------------------
void CMainFrame::SetBrightness(float fBrightness)
{
if(fBrightness < 0.1f || fBrightness > 5.0f)
return;
// update options
Options.textures.fBrightness = fBrightness;
// update display
for(int i = 0; i < Options.configs.nConfigs; i++)
Options.configs.Configs[i]->Palette.SetBrightness(fBrightness);
g_Textures.InformPaletteChanged();
//
// if current tool isn't the material tool, then redraw the texture bar
//
if ( ToolManager()->GetActiveToolID() != TOOL_FACEEDIT_MATERIAL )
{
m_TextureBar.RedrawWindow();
}
else
{
m_pFaceEditSheet->RedrawWindow();
}
// tell all the documents to redraw 3d views
UpdateAllDocViews( MAPVIEW_UPDATE_ONLY_3D | MAPVIEW_UPDATE_COLOR );
}
//-----------------------------------------------------------------------------
// Purpose:
// Input : nID -
// Output : Returns TRUE on success, FALSE on failure.
//-----------------------------------------------------------------------------
BOOL CMainFrame::OnView3dChangeBrightness(UINT nID)
{
float fBrightness = Options.textures.fBrightness;
float fModify = (nID == ID_VIEW3D_BRIGHTER) ? 0.2f : -0.2f;
SetBrightness(fBrightness + fModify);
return TRUE;
}
//-----------------------------------------------------------------------------
// Purpose: Brings up the sound browser
//-----------------------------------------------------------------------------
BOOL CMainFrame::OnSoundBrowser(UINT nID)
{
CSoundBrowser dlg("");
dlg.DoModal();
return TRUE;
}
//-----------------------------------------------------------------------------
// Purpose: Brings up the sound browser
//-----------------------------------------------------------------------------
BOOL CMainFrame::OnReloadSounds(UINT nID)
{
for ( int i = 0; i < SOUND_TYPE_COUNT; ++i )
{
g_Sounds.BuildSoundList( (SoundType_t)i );
}
return TRUE;
}
//-----------------------------------------------------------------------------
// Purpose: Toggles face edit mode, which encompasses two different tools, the
// materials editing tool and the displacement editing tool.
//
// The tool itself is set by the OnSetActive handler for each property
// page of the face properties sheet.
//-----------------------------------------------------------------------------
BOOL CMainFrame::OnApplicator(UINT nID)
{
bool bNewFaceEditMode = !IsInFaceEditMode();
//
// Show/hide face edit sheet/texturebar and update the selection set if need be.
//
EnableFaceEditMode(bNewFaceEditMode);
if (!bNewFaceEditMode)
{
ToolManager()->SetTool(TOOL_POINTER);
}
return TRUE;
}
//-----------------------------------------------------------------------------
// Purpose: Enables or disables face edit mode, updating the UI as necessary.
// When we are in face edit mode, the texture bar is hidden and the
// face edit property sheet is shown. The active tool is changed
// to either the material tool or the displacement tool based on which
// page in the property sheet is active.
//-----------------------------------------------------------------------------
void CMainFrame::EnableFaceEditMode(bool bEnable)
{
CMapDoc *pDoc = CMapDoc::GetActiveMapDoc();
if (!pDoc)
{
return;
}
ShowFaceEditSheetOrTextureBar(bEnable);
pDoc->UpdateForApplicator(bEnable);
}
//-----------------------------------------------------------------------------
// Purpose: Returns true if we are in face edit mode, false if not.
//-----------------------------------------------------------------------------
bool CMainFrame::IsInFaceEditMode()
{
if ((ToolManager()->GetActiveToolID() == TOOL_FACEEDIT_MATERIAL) || (ToolManager()->GetActiveToolID() == TOOL_FACEEDIT_DISP))
{
return true;
}
return false;
}
//-----------------------------------------------------------------------------
// Purpose: Manages the state of the texture applicator toobar button and menu item.
//-----------------------------------------------------------------------------
void CMainFrame::OnUpdateApplicatorUI(CCmdUI *pUI)
{
if (IsShellSessionActive())
{
pUI->Enable(FALSE);
}
else
{
pUI->SetCheck(IsInFaceEditMode());
pUI->Enable(CMapDoc::GetActiveMapDoc() ? TRUE : FALSE);
}
}
//-----------------------------------------------------------------------------
// Purpose: Invokes the prefab manager dialog.
//-----------------------------------------------------------------------------
void CMainFrame::OnToolsPrefabfactory(void)
{
CPrefabsDlg dlg;
dlg.DoModal();
CPrefabLibrary::LoadAllLibraries();
m_ObjectBar.UpdateListForTool( ToolManager()->GetActiveToolID());
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CMainFrame::OnHelpFinder(void)
{
APP()->OpenURL(ID_HELP_TOPICS, GetMainWnd()->GetSafeHwnd());
}
//-----------------------------------------------------------------------------
// Purpose:
// Input : pHelpInfo -
// Output : Returns TRUE on success, FALSE on failure.
//-----------------------------------------------------------------------------
BOOL CMainFrame::OnHelpInfo(HELPINFO *pHelpInfo)
{
return(Default());
}
//-----------------------------------------------------------------------------
// Purpose: Opens a URL in the default web browser.
//-----------------------------------------------------------------------------
void CMainFrame::OpenURL(const char *pszURL)
{
APP()->OpenURL(pszURL, m_hWnd);
}
//-----------------------------------------------------------------------------
// Purpose: Opens a URL in the default web browser by string ID.
//-----------------------------------------------------------------------------
void CMainFrame::OpenURL(UINT nID)
{
APP()->OpenURL(nID, m_hWnd);
}
//-----------------------------------------------------------------------------
// Purpose: Opens the URL that corresponds to the given string ID. This is used
// to hook menu items to URLs in the string table.
//-----------------------------------------------------------------------------
BOOL CMainFrame::OnHelpOpenURL(UINT nID)
{
OpenURL(nID);
return TRUE;
}
//-----------------------------------------------------------------------------
// Purpose: Activates or deactivates Undo/Redo.
//-----------------------------------------------------------------------------
void CMainFrame::SetUndoActive(BOOL bActive)
{
m_bUndoActive = bActive;
CMapDoc::GetActiveMapDoc()->SetUndoActive(bActive == TRUE);
}
//-----------------------------------------------------------------------------
// Purpose: Toggles the active state of Undo/Redo.
//-----------------------------------------------------------------------------
void CMainFrame::OnEditUndoredoactive(void)
{
SetUndoActive(!m_bUndoActive);
}
//-----------------------------------------------------------------------------
// Purpose: Manages the state of the Enable/Disable Undo/Redo menu item.
//-----------------------------------------------------------------------------
void CMainFrame::OnUpdateEditUndoredoactive(CCmdUI *pCmdUI)
{
pCmdUI->Enable(IsShellSessionActive() ? FALSE : TRUE);
pCmdUI->SetText(m_bUndoActive ? "Disable Undo/Redo" : "Enable Undo/Redo");
}
//-----------------------------------------------------------------------------
// Purpose:
// Input : nCode -
//-----------------------------------------------------------------------------
void CMainFrame::GlobalNotify(int nCode)
{
CMapDoc *pDoc = CMapDoc::GetActiveMapDoc();
switch (nCode)
{
//
// Active document changed. Update visgroup lists.
//
case WM_MAPDOC_CHANGED:
{
//
// Update the visgroups.
//
m_FilterControl.UpdateGroupList();
//
// If the Object Properties dialog has a Groups tab, update
// the groups tab.
//
if (pObjectProperties != NULL)
{
pObjectProperties->UpdateGrouplist();
}
if (pDoc != NULL)
{
pDoc->UpdateStatusbar();
//m_AnimationDlg.SelectionChanged(*pDoc->Selection_GetList());
}
m_ManifestFilterControl.UpdateManifestList();
break;
}
//
// Game configuration changed. Update texture and entity lists.
//
case WM_GAME_CHANGED:
{
pTextureBrowser->SetTextureFormat(g_pGameConfig->GetTextureFormat());
m_TextureBar.NotifyGraphicsChanged();
m_pFaceEditSheet->NotifyGraphicsChanged();
if (pDoc != NULL)
m_ObjectBar.UpdateListForTool( pDoc->GetTools()->GetActiveToolID());
break;
}
//
// Lighting preview window closed
//
case LPRV_WINDOWCLOSED:
{
m_bLightingPreviewOutputWindowShowing = false;
break;
}
}
}
//-----------------------------------------------------------------------------
// Purpose:
// Input : UINT -
// Output : Returns TRUE on success, FALSE on failure.
//-----------------------------------------------------------------------------
BOOL CMainFrame::OnFileNew(UINT)
{
return FALSE;
CNewDocType dlg;
dlg.m_iNewType = 0;
if(dlg.DoModal() != IDOK)
return TRUE;
return FALSE;
}
//-----------------------------------------------------------------------------
// Purpose: Saves the position and types of all 2D and 3D views in the active document.
// dvs: This really needs to be a text file instead of a binary file!
// Input : *pFile -
//-----------------------------------------------------------------------------
void CMainFrame::SaveWindowStates(std::fstream *pFile)
{
char szRootDir[MAX_PATH];
char szFullPath[MAX_PATH];
APP()->GetDirectory(DIR_PROGRAM, szRootDir);
Q_MakeAbsolutePath( szFullPath, MAX_PATH, "winstate.wc", szRootDir );
std::fstream file(szFullPath, std::ios::out | std::ios::binary);
CMapDoc *pDoc = CMapDoc::GetActiveMapDoc();
if (pDoc == NULL)
{
return;
}
file.write(WINSTATETAG, sizeof WINSTATETAG);
file.write((char*) &fVersion, sizeof fVersion);
CRect rectClient;
::GetClientRect(m_hWndMDIClient, &rectClient);
// write out each view
POSITION p = pDoc->GetFirstViewPosition();
while (p != NULL)
{
CView *pView = pDoc->GetNextView(p);
//
// Determine what type of view it is.
//
int iDrawType;
if (pView->IsKindOf(RUNTIME_CLASS(CMapView2D)))
{
file.write((char*) &WINSTATE2DVIEW, sizeof WINSTATE2DVIEW);
iDrawType = (int)((CMapView2D*)pView)->GetDrawType();
}
else if (pView->IsKindOf(RUNTIME_CLASS(CMapView3D)))
{
file.write((char*) &WINSTATE3DVIEW, sizeof WINSTATE3DVIEW);
iDrawType = (int)((CMapView3D*)pView)->GetDrawType();
}
else if (pView->IsKindOf(RUNTIME_CLASS(CMapViewLogical)))
{
file.write((char*) &WINSTATELOGICALVIEW, sizeof WINSTATELOGICALVIEW);
iDrawType = (int)((CMapViewLogical*)pView)->GetDrawType();
}
else
{
//
// It's a view type whose state we do not save - skip it.
//
continue;
}
//
// Write view's draw type.
//
file.write((char*) &iDrawType, sizeof iDrawType);
//
// Write position of view.
//
CRect rectView;
pView->GetParentFrame()->GetWindowRect(&rectView);
CPoint pt1 = rectView.TopLeft(), pt2 = rectView.BottomRight();
::ScreenToClient(m_hWndMDIClient, &pt1);
::ScreenToClient(m_hWndMDIClient, &pt2);
double left, top, right, bottom;
left = double(pt1.x) / double(rectClient.right);
top = double(pt1.y) / double(rectClient.bottom);
right = double(pt2.x) / double(rectClient.right);
bottom = double(pt2.y) / double(rectClient.bottom);
file.write((char*) &left, sizeof left);
file.write((char*) &top, sizeof top);
file.write((char*) &right, sizeof right);
file.write((char*) &bottom, sizeof bottom);
}
file.write((char *)&WINSTATEEND, sizeof WINSTATEEND);
}
//-----------------------------------------------------------------------------
// Purpose:
// Input : pFile -
//-----------------------------------------------------------------------------
void CMainFrame::LoadWindowStates(std::fstream *pFile)
{
char szRootDir[MAX_PATH];
char szFullPath[MAX_PATH];
APP()->GetDirectory(DIR_PROGRAM, szRootDir);
Q_MakeAbsolutePath( szFullPath, MAX_PATH, "winstate.wc", szRootDir );
std::fstream file( szFullPath, std::ios::in | std::ios::binary );
if (!file.is_open())
{
return;
}
char tag[sizeof(WINSTATETAG)];
file.read(tag, sizeof tag);
if(memcmp(tag, WINSTATETAG, sizeof tag))
{
file.seekg(-int(sizeof(tag)));
return;
}
float fThisVersion;
file.read((char*) &fThisVersion, sizeof fThisVersion);
CMapDoc *pDoc = CMapDoc::GetActiveMapDoc();
if(!pDoc)
return;
// get client rect of MDI CHILD for relative positioning information
CRect rectClient;
::GetClientRect(m_hWndMDIClient, &rectClient);
// keep list of views we've already modified, so if there
// are other views, we have to create them. this prevents
// us from having to delete all views and start over,
// which is a slower process than simply moving existing
// views.
CTypedPtrList<CPtrList, CView*> UsedViews;
SetDefaultChildType(FALSE);
while (1)
{
int iViewType;
file.read((char *)&iViewType, sizeof iViewType);
if ((file.eof()) || (iViewType == WINSTATEEND))
{
break;
}
int iDrawType;
file.read((char *)&iDrawType, sizeof iDrawType);
CView *pView = NULL;
// find a view we haven't used
POSITION p = pDoc->GetFirstViewPosition();
while (p != NULL)
{
CView *pThisView = pDoc->GetNextView(p);
// already used?
if (UsedViews.Find(pThisView))
continue;
// make sure it's the right type ..
if (iViewType == WINSTATE2DVIEW && !pThisView->IsKindOf(RUNTIME_CLASS(CMapView2D)))
continue;
if (iViewType == WINSTATELOGICALVIEW && !pThisView->IsKindOf(RUNTIME_CLASS(CMapViewLogical)))
continue;
if (iViewType == WINSTATE3DVIEW && !pThisView->IsKindOf(RUNTIME_CLASS(CMapView3D)))
continue;
// yes! so modify this one.
pView = pThisView;
UsedViews.AddTail(pView);
break;
}
CChildFrame *pFrame = NULL;
BOOL bNew = FALSE;
CDocTemplate *pTemplate = NULL;
if(!pView)
{
// if no view was created, we have to create a new one.
CMDIChildWnd* pActiveChild = MDIGetActive();
pTemplate = pDoc->GetDocTemplate();
pFrame = (CChildFrame*) pTemplate->CreateNewFrame(pDoc, pActiveChild);
pFrame->SetRedraw(FALSE);
pTemplate->InitialUpdateFrame(pFrame, pDoc, FALSE);
// find view in new frame
pView = pFrame->GetActiveView();
UsedViews.AddTail(pView);
bNew = TRUE;
}
else
{
// find frame based on this view
pFrame = (CChildFrame*) pView->GetParentFrame();
if(pFrame->bUsingSplitter)
pFrame->SetSplitterMode(FALSE);
}
// no redraws right now, please.
pFrame->SetRedraw(FALSE);
if (iViewType == WINSTATE3DVIEW)
{
//
// Handle import of old WinState files before draw types were consolidated
// into a single enumeration.
//
if ((iDrawType >= VIEW2D_XY) && (iDrawType <= VIEW2D_XZ))
{
iDrawType += 3;
}
pFrame->SetViewType((DrawType_t)iDrawType);
}
else if (iViewType == WINSTATE2DVIEW)
{
pFrame->SetViewType((DrawType_t)iDrawType);
}
else if (iViewType == WINSTATELOGICALVIEW)
{
pFrame->SetViewType( (DrawType_t)iDrawType );
}
// read positioning info
double left, top, right, bottom;
file.read((char*) &left, sizeof left);
file.read((char*) &top, sizeof top);
file.read((char*) &right, sizeof right);
file.read((char*) &bottom, sizeof bottom);
CRect r;
r.left = int(left * double(rectClient.right));
r.top = int(top * double(rectClient.bottom));
r.right = int(right * double(rectClient.right));
r.bottom = int(bottom * double(rectClient.bottom));
// Set the frame's position.
pFrame->MoveWindow(&r, FALSE);
// Call OnInitialUpdate before any rendering takes place.
if (bNew)
{
pTemplate->InitialUpdateFrame(pFrame, pDoc, TRUE);
}
// Enable WM_PAINT messages for the frame window.
pFrame->SetRedraw(TRUE);
// Update the window.
pFrame->Invalidate();
pFrame->UpdateWindow();
}
Invalidate();
UpdateWindow();
}
void CMainFrame::OnInitMenu( CMenu *pMenu )
{
}
void CMainFrame::OnHDR( void )
{
CMenu *pMenu= GetMenu();
UINT state = pMenu->GetMenuState(ID_HDR, MF_BYCOMMAND);
if (state & MF_CHECKED)
{
pMenu->CheckMenuItem(ID_HDR, MF_UNCHECKED | MF_BYCOMMAND);
g_bHDR = false;
}
else
{
pMenu->CheckMenuItem(ID_HDR, MF_CHECKED | MF_BYCOMMAND);
g_bHDR = true;
}
DrawMenuBar();
SignalUpdate( EVTYPE_LIGHTING_CHANGED );
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CMainFrame::OnSavewindowstate(void)
{
SaveWindowStates();
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CMainFrame::OnLoadwindowstate(void)
{
LoadWindowStates();
}
//-----------------------------------------------------------------------------
// Purpose: Changes the format of the units displayed in the status bar.
// Input : nID - Menu ID corresponding to a units format.
//-----------------------------------------------------------------------------
BOOL CMainFrame::OnUnits(UINT nID)
{
switch (nID)
{
case ID_MAP_UNITS_NONE:
{
Box3D::SetWorldUnits(Units_None);
break;
}
case ID_MAP_UNITS_INCHES:
{
Box3D::SetWorldUnits(Units_Inches);
break;
}
case ID_MAP_UNITS_FEET_INCHES:
{
Box3D::SetWorldUnits(Units_Feet_Inches);
break;
}
}
CMapDoc::GetActiveMapDoc()->UpdateStatusbar();
return TRUE;
}
//-----------------------------------------------------------------------------
// Purpose: Manages the state of decal application toolbar button.
//-----------------------------------------------------------------------------
void CMainFrame::OnUpdateUnits(CCmdUI *pCmdUI)
{
pCmdUI->Enable(!IsShellSessionActive());
if (pCmdUI->m_nID == ID_MAP_UNITS_NONE)
{
pCmdUI->SetCheck(Box3D::GetWorldUnits() == Units_None);
}
else if (pCmdUI->m_nID == ID_MAP_UNITS_INCHES)
{
pCmdUI->SetCheck(Box3D::GetWorldUnits() == Units_Inches);
}
else if (pCmdUI->m_nID == ID_MAP_UNITS_FEET_INCHES)
{
pCmdUI->SetCheck(Box3D::GetWorldUnits() == Units_Feet_Inches);
}
}
//-----------------------------------------------------------------------------
// Purpose:
// Input : pMsg -
// Output : Returns TRUE on success, FALSE on failure.
//-----------------------------------------------------------------------------
BOOL CMainFrame::PreTranslateMessage(MSG* pMsg)
{
//
// See if the message is a keydown and the current focus window is the
// ComboBox in the ObjectBar!
//
/*
if (pMsg->message == WM_KEYDOWN)
{
if ((GetFocus() == &m_ObjectBar) || (GetFocus() == &this->m_FilterControl))
{
AfxMessageBox("Ok");
return(TRUE);
}
}
*/
return(CMDIFrameWnd::PreTranslateMessage(pMsg));
}
//-----------------------------------------------------------------------------
// Purpose: Finds the next CChildFrame in the list of MDI child windows.
// Input : pCurChild - Child to search from.
//-----------------------------------------------------------------------------
CChildFrame *CMainFrame::GetNextMDIChildWnd(CChildFrame *pCurChild)
{
return GetNextMDIChildWndRecursive(pCurChild);
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
CChildFrame *CMainFrame::GetNextMDIChildWndRecursive(CWnd *pCurChild)
{
CWnd *pNextChild = NULL;
if (pCurChild == NULL)
{
// Get the first child window.
pNextChild = wndMDIClient.GetWindow(GW_CHILD);
}
else
{
// Get the next child window in the list.
pNextChild = pCurChild->GetWindow(GW_HWNDNEXT);
if (!pNextChild)
{
// No child windows exist in the MDIClient,
// or you are at the end of the list. This check
// will terminate any recursion.
return NULL;
}
}
// Check the kind of window
if (!pNextChild->GetWindow(GW_OWNER))
{
if (pNextChild->IsKindOf(RUNTIME_CLASS(CChildFrame)))
{
return (CChildFrame *)pNextChild;
}
}
// Not one we are interested in. Try the next one.
// Recurse over the window manager's list of windows.
return GetNextMDIChildWndRecursive(pNextChild);
}
//-----------------------------------------------------------------------------
// Purpose: Returns true if we are currently editing via the engine, false if not.
//-----------------------------------------------------------------------------
bool CMainFrame::IsShellSessionActive(void)
{
return(m_bShellSessionActive);
}
//-----------------------------------------------------------------------------
// Purpose: Manages the state of all Edit menu items and toolbar buttons.
//-----------------------------------------------------------------------------
void CMainFrame::OnUpdateEditFunction(CCmdUI *pCmdUI)
{
pCmdUI->Enable(!IsShellSessionActive());
}
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
void CMainFrame::ShowFaceEditSheetOrTextureBar( bool bShowFaceEditSheet )
{
if( bShowFaceEditSheet )
{
m_pFaceEditSheet->SetVisibility( true );
ShowControlBar( &m_TextureBar, FALSE, TRUE );
}
else
{
m_pFaceEditSheet->SetVisibility( false );
m_pFaceEditSheet->CloseAllPageDialogs();
ShowControlBar( &m_TextureBar, TRUE, TRUE );
}
}
//-----------------------------------------------------------------------------
// Purpose: Displays the search/replace dialog. It will be hide itself when the
// user closes it.
//-----------------------------------------------------------------------------
void CMainFrame::ShowSearchReplaceDialog(void)
{
if (m_pSearchReplaceDlg == NULL)
{
m_pSearchReplaceDlg = new CSearchReplaceDlg;
m_pSearchReplaceDlg->Create(this);
}
m_pSearchReplaceDlg->ShowWindow(SW_SHOW);
m_pSearchReplaceDlg->SetFocus();
}
//-----------------------------------------------------------------------------
// Purpose: Code found on codeproject.com.
//
// Makes sure we don't have bogus dialog bar information in the registry.
// This prevents a crash in the MFC code if a version of the editor with
// different toolbars was run before us.
//
// TODO: fix the registry settings if they are bad so we can still load the bar state
//
// Output : Returns true if it is safe to load the toolbar settings, false if not.
//-----------------------------------------------------------------------------
bool CMainFrame::VerifyBarState(void)
{
CDockState state;
state.LoadState("BarState");
for (int i = 0; i < state.m_arrBarInfo.GetSize(); i++)
{
CControlBarInfo* pInfo = (CControlBarInfo*)state.m_arrBarInfo[i];
Assert(pInfo != NULL);
int nDockedCount = pInfo->m_arrBarID.GetSize();
if (nDockedCount > 0)
{
for (int j = 0; j < nDockedCount; j++)
{
UINT nID = (UINT) pInfo->m_arrBarID[j];
if (nID == 0)
{
continue; // row separator
}
if (nID > 0xFFFF)
{
nID &= 0xFFFF; // placeholder - get the ID
}
if (GetControlBar(nID) == NULL)
{
return false;
}
}
}
if (!pInfo->m_bFloating) // floating dockbars can be created later
{
if (GetControlBar(pInfo->m_nBarID) == NULL)
{
return false; // invalid bar ID
}
}
}
return true;
}
//-----------------------------------------------------------------------------
// Purpose:
// Input : dwData -
// nCmd -
//-----------------------------------------------------------------------------
void CMainFrame::WinHelp(DWORD dwData, UINT nCmd)
{
// dvs: HACK: just punt them to the main help page
APP()->OpenURL(ID_HELP_TOPICS, m_hWnd);
}
Reference in New Issue View Git Blame Copy Permalink