CMake/Source/MFCDialog/CMakeSetupDialog.cpp

819 lines
22 KiB
C++
Raw Normal View History

// pcbuilderdialogDlg.cpp : implementation file
//
#include "stdafx.h"
#include "CMakeSetup.h"
2001-06-06 01:26:48 +04:00
#include "PathDialog.h"
#include "CMakeSetupDialog.h"
#include "CMakeCommandLineInfo.h"
#include "../cmCacheManager.h"
2001-05-30 23:28:55 +04:00
#include "../cmake.h"
2001-09-07 01:28:24 +04:00
#include "../cmMakefileGenerator.h"
#ifdef _DEBUG
#define new DEBUG_NEW
#undef THIS_FILE
static char THIS_FILE[] = __FILE__;
#endif
/////////////////////////////////////////////////////////////////////////////
// CAboutDlg dialog used for App About
class CAboutDlg : public CDialog
{
public:
CAboutDlg();
// Dialog Data
//{{AFX_DATA(CAboutDlg)
enum { IDD = IDD_ABOUTBOX };
//}}AFX_DATA
// ClassWizard generated virtual function overrides
//{{AFX_VIRTUAL(CAboutDlg)
protected:
virtual void DoDataExchange(CDataExchange* pDX); // DDX/DDV support
//}}AFX_VIRTUAL
// Implementation
protected:
//{{AFX_MSG(CAboutDlg)
//}}AFX_MSG
DECLARE_MESSAGE_MAP()
};
CAboutDlg::CAboutDlg() : CDialog(CAboutDlg::IDD)
{
//{{AFX_DATA_INIT(CAboutDlg)
//}}AFX_DATA_INIT
}
void CAboutDlg::DoDataExchange(CDataExchange* pDX)
{
CDialog::DoDataExchange(pDX);
//{{AFX_DATA_MAP(CAboutDlg)
//}}AFX_DATA_MAP
}
BEGIN_MESSAGE_MAP(CAboutDlg, CDialog)
//{{AFX_MSG_MAP(CAboutDlg)
// No message handlers
//}}AFX_MSG_MAP
END_MESSAGE_MAP();
void MFCMessageCallback(const char* m, const char* title, bool& nomore)
{
std::string message = m;
message += "\n\n(Press Cancel to suppress any further messages.)";
if(::MessageBox(0, message.c_str(), title,
MB_OKCANCEL) == IDCANCEL)
{
nomore = true;
}
}
/////////////////////////////////////////////////////////////////////////////
// CMakeSetupDialog dialog
CMakeSetupDialog::CMakeSetupDialog(const CMakeCommandLineInfo& cmdInfo,
CWnd* pParent /*=NULL*/)
: CDialog(CMakeSetupDialog::IDD, pParent)
{
cmSystemTools::SetErrorCallback(MFCMessageCallback);
2001-05-17 20:08:46 +04:00
m_RegistryKey = "Software\\Kitware\\CMakeSetup\\Settings\\StartPath";
//{{AFX_DATA_INIT(CMakeSetupDialog)
2001-09-25 22:39:32 +04:00
m_WhereSource = cmdInfo.m_WhereSource;
m_WhereBuild = cmdInfo.m_WhereBuild;
m_GeneratorChoiceString = _T("");
//}}AFX_DATA_INIT
// Note that LoadIcon does not require a subsequent DestroyIcon in Win32
m_hIcon = AfxGetApp()->LoadIcon(IDR_MAINFRAME);
m_BuildPathChanged = false;
2001-05-30 23:28:55 +04:00
// Find the path to the cmake.exe executable
char fname[1024];
::GetModuleFileName(NULL,fname,1023);
// extract just the path part
m_PathToExecutable = cmSystemTools::GetProgramPath(fname).c_str();
// add the cmake.exe to the path
m_PathToExecutable += "/cmake.exe";
2001-06-26 17:55:35 +04:00
m_oldCX = -1;
m_deltaXRemainder = 0;
}
void CMakeSetupDialog::DoDataExchange(CDataExchange* pDX)
{
CDialog::DoDataExchange(pDX);
//{{AFX_DATA_MAP(CMakeSetupDialog)
2001-09-07 01:28:24 +04:00
DDX_Control(pDX, IDC_Generator, m_GeneratorChoice);
DDX_Control(pDX, IDC_OK, m_OKButton);
DDX_Control(pDX, IDCANCEL, m_CancelButton);
DDX_CBStringExact(pDX, IDC_WhereSource, m_WhereSource);
DDX_CBStringExact(pDX, IDC_WhereBuild, m_WhereBuild);
DDX_Control(pDX, IDC_FRAME, m_ListFrame);
2001-05-21 18:47:00 +04:00
DDX_Control(pDX, IDC_WhereSource, m_WhereSourceControl);
DDX_Control(pDX, IDC_WhereBuild, m_WhereBuildControl);
DDX_Control(pDX, IDC_LIST2, m_CacheEntriesList);
DDX_Control(pDX, IDC_MouseHelpCaption, m_MouseHelp);
DDX_Control(pDX, IDC_CMAKE_VERSION, m_VersionDisplay);
DDX_Control(pDX, IDC_BuildProjects, m_Configure);
2001-09-07 01:28:24 +04:00
DDX_CBStringExact(pDX, IDC_Generator, m_GeneratorChoiceString);
//}}AFX_DATA_MAP
}
BEGIN_MESSAGE_MAP(CMakeSetupDialog, CDialog)
//{{AFX_MSG_MAP(CMakeSetupDialog)
ON_WM_SYSCOMMAND()
ON_WM_PAINT()
ON_WM_QUERYDRAGICON()
ON_BN_CLICKED(IDC_BUTTON2, OnBrowseWhereSource)
ON_BN_CLICKED(IDC_BuildProjects, OnConfigure)
ON_BN_CLICKED(IDC_BUTTON3, OnBrowseWhereBuild)
ON_CBN_EDITCHANGE(IDC_WhereBuild, OnChangeWhereBuild)
ON_CBN_SELCHANGE(IDC_WhereBuild, OnSelendokWhereBuild)
ON_CBN_EDITCHANGE(IDC_WhereSource, OnChangeWhereSource)
2001-05-21 18:47:00 +04:00
ON_CBN_SELENDOK(IDC_WhereSource, OnSelendokWhereSource)
ON_WM_SIZE()
ON_WM_GETMINMAXINFO()
ON_BN_CLICKED(IDC_OK, OnOk)
2001-09-07 01:28:24 +04:00
ON_BN_CLICKED(IDCANCEL, OnCancel)
ON_CBN_EDITCHANGE(IDC_Generator, OnEditchangeGenerator)
2001-05-21 18:47:00 +04:00
//}}AFX_MSG_MAP
END_MESSAGE_MAP()
/////////////////////////////////////////////////////////////////////////////
// CMakeSetupDialog message handlers
2001-05-21 18:47:00 +04:00
BOOL CMakeSetupDialog::OnInitDialog()
{
CDialog::OnInitDialog();
// Add "About..." menu item to system menu.
// IDM_ABOUTBOX must be in the system command range.
ASSERT((IDM_ABOUTBOX & 0xFFF0) == IDM_ABOUTBOX);
ASSERT(IDM_ABOUTBOX < 0xF000);
CMenu* pSysMenu = GetSystemMenu(FALSE);
if (pSysMenu != NULL)
{
CString strAboutMenu;
strAboutMenu.LoadString(IDS_ABOUTBOX);
if (!strAboutMenu.IsEmpty())
{
pSysMenu->AppendMenu(MF_SEPARATOR);
pSysMenu->AppendMenu(MF_STRING, IDM_ABOUTBOX, strAboutMenu);
}
}
// Set the icon for this dialog. The framework does this automatically
// when the application's main window is not a dialog
SetIcon(m_hIcon, TRUE); // Set big icon
SetIcon(m_hIcon, FALSE); // Set small icon
2001-05-21 18:47:00 +04:00
// Load source and build dirs from registry
this->LoadFromRegistry();
2001-09-07 01:28:24 +04:00
cmake m; // force a register of generators
std::vector<std::string> names;
cmMakefileGenerator::GetRegisteredGenerators(names);
for(std::vector<std::string>::iterator i = names.begin();
i != names.end(); ++i)
{
m_GeneratorChoice.AddString(i->c_str());
}
m_GeneratorChoiceString = "Visual Studio 6";
2001-05-21 18:47:00 +04:00
// try to load the cmake cache from disk
this->LoadCacheFromDiskToGUI();
m_WhereBuildControl.LimitText(2048);
m_WhereSourceControl.LimitText(2048);
2001-09-07 01:28:24 +04:00
m_GeneratorChoice.LimitText(2048);
2001-05-24 19:47:21 +04:00
// Set the version number
char tmp[1024];
sprintf(tmp,"Version %d.%d", cmMakefile::GetMajorVersion(),
cmMakefile::GetMinorVersion());
2001-05-31 23:48:35 +04:00
SetDlgItemText(IDC_CMAKE_VERSION, tmp);
this->UpdateData(FALSE);
return TRUE; // return TRUE unless you set the focus to a control
}
2001-05-21 18:47:00 +04:00
// About dialog invoke
void CMakeSetupDialog::OnSysCommand(UINT nID, LPARAM lParam)
{
if ((nID & 0xFFF0) == IDM_ABOUTBOX)
{
CAboutDlg dlgAbout;
dlgAbout.DoModal();
}
else
{
CDialog::OnSysCommand(nID, lParam);
}
}
// If you add a minimize button to your dialog, you will need the code below
// to draw the icon. For MFC applications using the document/view model,
// this is automatically done for you by the framework.
void CMakeSetupDialog::OnPaint()
{
if (IsIconic())
{
CPaintDC dc(this); // device context for painting
SendMessage(WM_ICONERASEBKGND, (WPARAM) dc.GetSafeHdc(), 0);
// Center icon in client rectangle
int cxIcon = GetSystemMetrics(SM_CXICON);
int cyIcon = GetSystemMetrics(SM_CYICON);
CRect rect;
GetClientRect(&rect);
int x = (rect.Width() - cxIcon + 1) / 2;
int y = (rect.Height() - cyIcon + 1) / 2;
// Draw the icon
dc.DrawIcon(x, y, m_hIcon);
}
else
{
CDialog::OnPaint();
}
}
// The system calls this to obtain the cursor to display while the user drags
// the minimized window.
HCURSOR CMakeSetupDialog::OnQueryDragIcon()
{
return (HCURSOR) m_hIcon;
}
2001-05-21 18:47:00 +04:00
// Browse button
bool CMakeSetupDialog::Browse(CString &result, const char *title)
{
2001-06-06 01:26:48 +04:00
CPathDialog dlg("Select Path", title, result);
if(dlg.DoModal()==IDOK)
{
result = dlg.GetPathName();
return true;
}
else
{
2001-06-06 01:26:48 +04:00
return false;
}
}
2001-05-21 18:47:00 +04:00
void CMakeSetupDialog::SaveToRegistry()
{
HKEY hKey;
DWORD dwDummy;
if(RegCreateKeyEx(HKEY_CURRENT_USER,
m_RegistryKey,
0, "", REG_OPTION_NON_VOLATILE, KEY_READ|KEY_WRITE,
NULL, &hKey, &dwDummy) != ERROR_SUCCESS)
{
return;
}
else
{
2001-09-25 22:39:32 +04:00
// save some values
2001-05-21 18:47:00 +04:00
CString regvalue;
2001-09-25 22:39:32 +04:00
this->ReadRegistryValue(hKey, &(regvalue),"WhereSource1","C:\\");
int shiftEnd = 9;
2001-05-21 18:47:00 +04:00
if(m_WhereSource != regvalue)
{
2001-09-25 22:39:32 +04:00
char keyName[1024];
char keyName2[1024];
int i;
for (i = 2; i < 10; ++i)
{
regvalue = "";
sprintf(keyName,"WhereSource%i",i);
this->ReadRegistryValue(hKey, &(regvalue),keyName,"");
// check for short circuit, if the new value is already in
// the list then we stop
if (m_WhereSource == regvalue)
{
shiftEnd = i - 1;
}
}
for (i = shiftEnd; i; --i)
{
regvalue = "";
sprintf(keyName,"WhereSource%i",i);
sprintf(keyName2,"WhereSource%i",i+1);
this->ReadRegistryValue(hKey, &(regvalue),keyName,"");
if (strlen(regvalue))
{
RegSetValueEx(hKey, _T(keyName2), 0, REG_SZ,
(CONST BYTE *)(const char *)regvalue,
regvalue.GetLength());
}
}
RegSetValueEx(hKey, _T("WhereSource1"), 0, REG_SZ,
2001-05-21 18:47:00 +04:00
(CONST BYTE *)(const char *)m_WhereSource,
m_WhereSource.GetLength());
}
2001-09-25 22:39:32 +04:00
this->ReadRegistryValue(hKey, &(regvalue),"WhereBuild1","C:\\");
2001-05-21 18:47:00 +04:00
if(m_WhereBuild != regvalue)
{
2001-09-25 22:39:32 +04:00
int i;
char keyName[1024];
char keyName2[1024];
for (i = 2; i < 10; ++i)
{
regvalue = "";
sprintf(keyName,"WhereBuild%i",i);
this->ReadRegistryValue(hKey, &(regvalue),keyName,"");
// check for short circuit, if the new value is already in
// the list then we stop
if (m_WhereBuild == regvalue)
{
shiftEnd = i - 1;
}
}
for (i = shiftEnd; i; --i)
{
regvalue = "";
sprintf(keyName,"WhereBuild%i",i);
sprintf(keyName2,"WhereBuild%i",i+1);
this->ReadRegistryValue(hKey, &(regvalue),keyName,"");
if (strlen(regvalue))
{
RegSetValueEx(hKey, _T(keyName2), 0, REG_SZ,
(CONST BYTE *)(const char *)regvalue,
regvalue.GetLength());
}
}
RegSetValueEx(hKey, _T("WhereBuild1"), 0, REG_SZ,
2001-05-21 18:47:00 +04:00
(CONST BYTE *)(const char *)m_WhereBuild,
m_WhereBuild.GetLength());
}
}
RegCloseKey(hKey);
}
void CMakeSetupDialog::ReadRegistryValue(HKEY hKey,
CString *val,
const char *key,
const char *adefault)
{
DWORD dwType, dwSize;
char *pb;
dwType = REG_SZ;
pb = val->GetBuffer(MAX_PATH);
dwSize = MAX_PATH;
if(RegQueryValueEx(hKey,_T(key), NULL, &dwType,
(BYTE *)pb, &dwSize) != ERROR_SUCCESS)
{
val->ReleaseBuffer();
*val = _T(adefault);
}
else
{
val->ReleaseBuffer();
}
}
void CMakeSetupDialog::LoadFromRegistry()
{
HKEY hKey;
if(RegOpenKeyEx(HKEY_CURRENT_USER,
m_RegistryKey,
0, KEY_READ, &hKey) != ERROR_SUCCESS)
{
return;
}
else
{
2001-05-21 18:47:00 +04:00
// load some values
if (m_WhereSource.IsEmpty())
{
2001-09-25 22:39:32 +04:00
this->ReadRegistryValue(hKey, &(m_WhereSource),"WhereSource1","C:\\");
}
if (m_WhereBuild.IsEmpty())
{
2001-09-25 22:39:32 +04:00
this->ReadRegistryValue(hKey, &(m_WhereBuild),"WhereBuild1","C:\\");
}
2001-05-21 18:47:00 +04:00
m_WhereSourceControl.AddString(m_WhereSource);
m_WhereBuildControl.AddString(m_WhereBuild);
2001-09-25 22:39:32 +04:00
char keyname[1024];
2001-05-21 18:47:00 +04:00
CString regvalue;
2001-09-25 22:39:32 +04:00
int i;
for (i = 2; i <= 10; ++i)
{
sprintf(keyname,"WhereSource%i",i);
regvalue = "";
this->ReadRegistryValue(hKey, &(regvalue),keyname,"C:\\");
if (strcmp("C:\\",regvalue))
{
m_WhereSourceControl.AddString(regvalue);
}
sprintf(keyname,"WhereBuild%i",i);
regvalue = "";
this->ReadRegistryValue(hKey, &(regvalue),keyname,"C:\\");
if (strcmp("C:\\",regvalue))
{
m_WhereBuildControl.AddString(regvalue);
}
}
}
RegCloseKey(hKey);
}
2001-05-21 18:47:00 +04:00
// Callback for browse source button
void CMakeSetupDialog::OnBrowseWhereSource()
{
this->UpdateData();
Browse(m_WhereSource, "Enter Path to Source");
this->UpdateData(false);
this->OnChangeWhereSource();
}
// Callback for browser build button
void CMakeSetupDialog::OnBrowseWhereBuild()
{
this->UpdateData();
Browse(m_WhereBuild, "Enter Path to Build");
this->UpdateData(false);
this->OnChangeWhereBuild();
}
void CMakeSetupDialog::RunCMake(bool generateProjectFiles)
{
if(!cmSystemTools::FileExists(m_WhereBuild))
{
std::string message =
"Build directory does not exist, should I create it?\n\n"
"Directory: ";
message += (const char*)m_WhereBuild;
if(MessageBox(message.c_str(), "Create Directory", MB_OKCANCEL) == IDOK)
{
cmSystemTools::MakeDirectory(m_WhereBuild);
}
else
{
MessageBox("Build Project aborted, nothing done.");
return;
}
}
2001-05-30 23:28:55 +04:00
// set the wait cursor
2001-07-25 00:46:33 +04:00
::SetCursor(LoadCursor(NULL, IDC_WAIT));
2001-05-30 23:28:55 +04:00
// get all the info from the dialog
2001-04-24 20:40:37 +04:00
this->UpdateData();
// always save the current gui values to disk
this->SaveCacheFromGUI();
2001-05-02 00:34:53 +04:00
// Make sure we are working from the cache on disk
this->LoadCacheFromDiskToGUI();
2001-05-30 23:28:55 +04:00
// create a cmake object
cmake make;
// create the arguments for the cmake object
std::vector<std::string> args;
args.push_back((const char*)m_PathToExecutable);
std::string arg;
arg = "-H";
arg += m_WhereSource;
args.push_back(arg);
arg = "-B";
arg += m_WhereBuild;
args.push_back(arg);
2001-09-07 01:28:24 +04:00
arg = "-G";
arg += m_GeneratorChoiceString;
args.push_back(arg);
2001-05-30 23:28:55 +04:00
// run the generate process
if(make.Generate(args, generateProjectFiles) != 0)
2001-05-30 23:28:55 +04:00
{
cmSystemTools::Error(
"Error in generation process, project files may be invalid");
2001-06-12 02:00:38 +04:00
cmSystemTools::ResetErrorOccuredFlag();
2001-05-30 23:28:55 +04:00
}
// update the GUI with any new values in the caused by the
// generation process
this->LoadCacheFromDiskToGUI();
// save source and build paths to registry
this->SaveToRegistry();
2001-05-30 23:28:55 +04:00
// path is up-to-date now
m_BuildPathChanged = false;
2001-05-30 23:28:55 +04:00
// put the cursor back
::SetCursor(LoadCursor(NULL, IDC_ARROW));
}
// Callback for build projects button
void CMakeSetupDialog::OnConfigure()
{
this->RunCMake(false);
}
2001-05-21 18:47:00 +04:00
// callback for combo box menu where build selection
void CMakeSetupDialog::OnSelendokWhereBuild()
{
2001-05-30 23:28:55 +04:00
m_WhereBuildControl.GetLBText(m_WhereBuildControl.GetCurSel(),
m_WhereBuild);
2001-06-26 17:55:35 +04:00
m_WhereBuildControl.SetWindowText( m_WhereBuild);
2001-05-21 18:47:00 +04:00
this->UpdateData(FALSE);
this->OnChangeWhereBuild();
}
// callback for combo box menu where source selection
void CMakeSetupDialog::OnSelendokWhereSource()
{
2001-05-30 23:28:55 +04:00
m_WhereSourceControl.GetLBText(m_WhereSourceControl.GetCurSel(),
m_WhereSource);
2001-05-21 18:47:00 +04:00
this->UpdateData(FALSE);
this->OnChangeWhereSource();
}
// callback for chaing source directory
void CMakeSetupDialog::OnChangeWhereSource()
{
}
// callback for changing the build directory
void CMakeSetupDialog::OnChangeWhereBuild()
{
this->UpdateData();
m_CacheEntriesList.RemoveAll();
2001-07-16 18:15:17 +04:00
m_CacheEntriesList.ShowWindow(SW_SHOW);
this->LoadCacheFromDiskToGUI();
m_BuildPathChanged = true;
2001-05-21 18:47:00 +04:00
}
// copy from the cache manager to the cache edit list box
void CMakeSetupDialog::FillCacheGUIFromCacheManager()
{
int size = m_CacheEntriesList.GetItems().size();
bool reverseOrder = false;
// if there are already entries in the cache, then
// put the new ones in the top, so they show up first
if(size)
{
reverseOrder = true;
}
// all the current values are not new any more
std::set<CPropertyItem*> items = m_CacheEntriesList.GetItems();
for(std::set<CPropertyItem*>::iterator i = items.begin();
i != items.end(); ++i)
{
CPropertyItem* item = *i;
item->m_NewValue = false;
}
2001-04-25 00:49:12 +04:00
const cmCacheManager::CacheEntryMap &cache =
cmCacheManager::GetInstance()->GetCacheMap();
if(cache.size() == 0)
{
m_OKButton.EnableWindow(false);
}
else
{
m_OKButton.EnableWindow(true);
}
2001-04-25 00:49:12 +04:00
for(cmCacheManager::CacheEntryMap::const_iterator i = cache.begin();
i != cache.end(); ++i)
{
const char* key = i->first.c_str();
2001-04-25 00:49:12 +04:00
const cmCacheManager::CacheEntry& value = i->second;
switch(value.m_Type )
{
case cmCacheManager::BOOL:
if(cmSystemTools::IsOn(value.m_Value.c_str()))
2001-04-24 20:40:37 +04:00
{
m_CacheEntriesList.AddProperty(key,
"ON",
2001-04-26 22:53:44 +04:00
value.m_HelpString.c_str(),
CPropertyList::COMBO,"ON|OFF",
reverseOrder
);
2001-04-24 20:40:37 +04:00
}
else
{
m_CacheEntriesList.AddProperty(key,
"OFF",
2001-04-26 22:53:44 +04:00
value.m_HelpString.c_str(),
CPropertyList::COMBO,"ON|OFF",
reverseOrder
);
2001-04-24 20:40:37 +04:00
}
break;
case cmCacheManager::PATH:
2001-04-26 22:53:44 +04:00
m_CacheEntriesList.AddProperty(key,
value.m_Value.c_str(),
value.m_HelpString.c_str(),
CPropertyList::PATH,"",
reverseOrder
);
break;
case cmCacheManager::FILEPATH:
2001-04-26 22:53:44 +04:00
m_CacheEntriesList.AddProperty(key,
value.m_Value.c_str(),
value.m_HelpString.c_str(),
CPropertyList::FILE,"",
reverseOrder
);
break;
case cmCacheManager::STRING:
2001-04-26 22:53:44 +04:00
m_CacheEntriesList.AddProperty(key,
value.m_Value.c_str(),
value.m_HelpString.c_str(),
CPropertyList::EDIT,"",
reverseOrder
);
break;
case cmCacheManager::INTERNAL:
m_CacheEntriesList.RemoveProperty(key);
break;
}
}
// redraw the list
m_CacheEntriesList.SetTopIndex(0);
m_CacheEntriesList.Invalidate();
}
2001-05-21 18:47:00 +04:00
// copy from the list box to the cache manager
void CMakeSetupDialog::FillCacheManagerFromCacheGUI()
{
2001-05-31 23:48:35 +04:00
cmCacheManager::GetInstance()->GetCacheMap();
2001-04-24 22:19:13 +04:00
std::set<CPropertyItem*> items = m_CacheEntriesList.GetItems();
for(std::set<CPropertyItem*>::iterator i = items.begin();
i != items.end(); ++i)
{
2001-04-24 21:32:31 +04:00
CPropertyItem* item = *i;
cmCacheManager::CacheEntry *entry =
2001-05-30 23:28:55 +04:00
cmCacheManager::GetInstance()->GetCacheEntry(
(const char*)item->m_propName);
if (entry)
{
entry->m_Value = item->m_curValue;
}
}
}
//! Load cache file from m_WhereBuild and display in GUI editor
void CMakeSetupDialog::LoadCacheFromDiskToGUI()
{
if(m_WhereBuild != "")
{
cmCacheManager::GetInstance()->LoadCache(m_WhereBuild);
this->FillCacheGUIFromCacheManager();
2001-09-07 01:28:24 +04:00
if(cmCacheManager::GetInstance()->GetCacheEntry("CMAKE_GENERATOR"))
{
std::string curGen =
cmCacheManager::GetInstance()->GetCacheEntry("CMAKE_GENERATOR")->m_Value;
if(m_GeneratorChoiceString != curGen.c_str())
{
m_GeneratorChoiceString = curGen.c_str();
this->UpdateData(FALSE);
}
}
}
}
//! Save GUI values to cmCacheManager and then save to disk.
void CMakeSetupDialog::SaveCacheFromGUI()
{
this->FillCacheManagerFromCacheGUI();
if(m_WhereBuild != "")
{
cmCacheManager::GetInstance()->SaveCache(m_WhereBuild);
}
}
2001-05-21 18:47:00 +04:00
void CMakeSetupDialog::OnSize(UINT nType, int cx, int cy)
{
2001-07-11 21:06:41 +04:00
if (nType == SIZE_MINIMIZED)
{
CDialog::OnSize(nType, cx, cy);
return;
}
2001-06-26 17:55:35 +04:00
if (m_oldCX == -1)
{
m_oldCX = cx;
m_oldCY = cy;
}
int deltax = cx - m_oldCX;
int deltay = cy - m_oldCY;
m_oldCX = cx;
m_oldCY = cy;
CDialog::OnSize(nType, cx, cy);
2001-06-26 17:55:35 +04:00
if (deltax == 0 && deltay == 0)
{
return;
}
if(m_CacheEntriesList.m_hWnd)
{
2001-06-26 17:55:35 +04:00
// get the original sizes/positions
CRect cRect;
m_ListFrame.GetWindowRect(&cRect);
m_ListFrame.SetWindowPos(&wndTop, cRect.left, cRect.top,
cRect.Width() + deltax,
cRect.Height() + deltay,
SWP_NOMOVE | SWP_NOZORDER);
2001-06-26 17:55:35 +04:00
m_CacheEntriesList.GetWindowRect(&cRect);
m_CacheEntriesList.SetWindowPos(&wndTop, cRect.left, cRect.top,
cRect.Width() + deltax,
cRect.Height() + deltay,
SWP_NOMOVE | SWP_NOZORDER);
m_VersionDisplay.SetWindowPos(&wndTop, 5, cy-23, 0, 0,
SWP_NOSIZE | SWP_NOZORDER);
deltax = deltax + m_deltaXRemainder;
m_deltaXRemainder = deltax%2;
m_MouseHelp.GetWindowRect(&cRect);
this->ScreenToClient(&cRect);
m_MouseHelp.SetWindowPos(&wndTop, cRect.left + deltax/2,
cRect.top + deltay,
0, 0,
SWP_NOSIZE | SWP_NOZORDER);
2001-06-26 17:55:35 +04:00
m_Configure.GetWindowRect(&cRect);
2001-06-26 17:55:35 +04:00
this->ScreenToClient(&cRect);
m_Configure.SetWindowPos(&wndTop, cRect.left + deltax/2,
2001-06-26 17:55:35 +04:00
cRect.top + deltay,
0, 0,
SWP_NOSIZE | SWP_NOZORDER);
2001-06-26 17:55:35 +04:00
m_CancelButton.GetWindowRect(&cRect);
this->ScreenToClient(&cRect);
m_CancelButton.SetWindowPos(&wndTop, cRect.left + deltax/2,
cRect.top + deltay,
0, 0,
SWP_NOSIZE | SWP_NOZORDER);
m_OKButton.GetWindowRect(&cRect);
this->ScreenToClient(&cRect);
m_OKButton.SetWindowPos(&wndTop, cRect.left + deltax/2,
cRect.top + deltay,
0, 0,
SWP_NOSIZE | SWP_NOZORDER);
}
}
void CMakeSetupDialog::OnGetMinMaxInfo( MINMAXINFO FAR* lpMMI )
{
lpMMI->ptMinTrackSize.x = 550;
lpMMI->ptMinTrackSize.y = 272;
}
void CMakeSetupDialog::OnCancel()
{
if(m_CacheEntriesList.IsDirty())
{
if(MessageBox("You have changed options but not rebuilt, "
"are you sure you want to exit?", "Confirm Exit",
MB_YESNO) == IDYES)
{
CDialog::OnOK();
}
}
else
{
CDialog::OnOK();
}
}
void CMakeSetupDialog::OnOk()
{
m_CacheEntriesList.ClearDirty();
this->RunCMake(true);
2001-09-15 00:26:56 +04:00
cmMakefileGenerator::UnRegisterGenerators();
CDialog::OnOK();
}
2001-09-07 01:28:24 +04:00
void CMakeSetupDialog::OnEditchangeGenerator()
{
// TODO: Add your control notification handler code here
}