kolan
/
CMake
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity
CMake/Source/WXDialog/CMakeSetupFrame.cpp

1776 lines
55 KiB
C++
Raw Blame History

/*=========================================================================
Program: WXDialog - wxWidgets X-platform GUI Front-End for CMake
Module: $RCSfile$
Language: C++
Date: $Date$
Version: $Revision$
Author: Jorgen Bodde
Copyright (c) 2002 Kitware, Inc., Insight Consortium. All rights reserved.
See Copyright.txt or http://www.cmake.org/HTML/Copyright.html for details.
This software is distributed WITHOUT ANY WARRANTY; without even
the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
PURPOSE. See the above copyright notices for more information.
=========================================================================*/
#if defined(__GNUG__) && !defined(__APPLE__)
#pragma implementation "CMakeSetupFrame.h"
#endif
// For compilers that support precompilation, includes "wx/wx.h".
#include "wx/wxprec.h"
#ifdef __BORLANDC__
#pragma hdrstop
#endif
#ifndef WX_PRECOMP
#include "wx/wx.h"
#endif
////@begin includes
////@end includes
#include <wx/dirdlg.h>
#include <wx/msgdlg.h>
#include <wx/filename.h>
#include "CMakeSetupFrame.h"
#include "PropertyList.h"
#include "app_resources.h"
#include "CMakeIcon.xpm"
#include "aboutdlg.h"
// cmake includes
#include "../cmListFileCache.h"
#include "../cmCacheManager.h"
#include "../cmGlobalGenerator.h"
#include "../cmDynamicLoader.h"
////@begin XPM images
////@end XPM images
/*!
* CMakeSetupFrm type definition
*/
IMPLEMENT_CLASS( CMakeSetupFrm, wxFrame )
/*!
* CMakeSetupFrm event table definition
*/
BEGIN_EVENT_TABLE( CMakeSetupFrm, wxFrame )
////@begin CMakeSetupFrm event table entries
EVT_CLOSE( CMakeSetupFrm::OnCloseWindow )
EVT_SPLITTER_SASH_POS_CHANGING( ID_SPLITTERWINDOW, CMakeSetupFrm::OnSplitterPosChanging )
EVT_SPLITTER_DCLICK( ID_SPLITTERWINDOW, CMakeSetupFrm::OnSplitterwindowSashDClick )
EVT_BUTTON( ID_BROWSE_PROJECT, CMakeSetupFrm::OnButtonBrowseProject )
EVT_TEXT( ID_SOURCE_BUILD_PATH, CMakeSetupFrm::OnSourceBuildPathUpdated )
EVT_TEXT_ENTER( ID_SOURCE_BUILD_PATH, CMakeSetupFrm::OnSourceBuildPathEnter )
EVT_BUTTON( ID_BROWSE_BUILD, CMakeSetupFrm::OnButtonBrowseBuild )
EVT_COMBOBOX( ID_SEARCHQUERY, CMakeSetupFrm::OnSearchquerySelected )
EVT_TEXT( ID_SEARCHQUERY, CMakeSetupFrm::OnSearchqueryUpdated )
EVT_CHECKBOX( ID_SHOW_ADVANCED, CMakeSetupFrm::OnShowAdvancedValues )
EVT_GRID_CELL_CHANGE( CMakeSetupFrm::OnCellChange )
EVT_GRID_SELECT_CELL( CMakeSetupFrm::OnGridSelectCell )
EVT_MOTION( CMakeSetupFrm::OnPropertyMotion )
EVT_BUTTON( ID_DO_CONFIGURE, CMakeSetupFrm::OnButtonConfigure )
EVT_BUTTON( ID_DO_OK, CMakeSetupFrm::OnButtonOk )
EVT_BUTTON( ID_DO_CANCEL, CMakeSetupFrm::OnButtonCancel )
EVT_BUTTON( ID_DO_DELETE_CACHE, CMakeSetupFrm::OnButtonDeleteCache )
EVT_BUTTON( ID_CLEAR_LOG, CMakeSetupFrm::OnClearLogClick )
EVT_BUTTON( ID_BROWSE_GRID, CMakeSetupFrm::OnBrowseGridClick )
EVT_MENU( ID_MENU_RELOAD_CACHE, CMakeSetupFrm::OnMenuReloadCacheClick )
EVT_MENU( ID_MENU_DELETE_CACHE, CMakeSetupFrm::OnMenuDeleteCacheClick )
EVT_MENU( ID_MENU_QUIT, CMakeSetupFrm::OnMenuQuitClick )
EVT_MENU( ID_MENU_CONFIGURE, CMakeSetupFrm::OnMenuConfigureClick )
EVT_MENU( ID_MENU_EXITGENERATE, CMakeSetupFrm::OnMenuGenerateClick )
EVT_MENU( ID_MENU_TOGGLE_ADVANCED, CMakeSetupFrm::OnMenuToggleAdvancedClick )
EVT_MENU( ID_CMAKE_OPTIONS, CMakeSetupFrm::OnOptionsClick )
EVT_MENU( ID_ABOUTDLG, CMakeSetupFrm::OnAboutClick )
////@end CMakeSetupFrm event table entries
EVT_MENU_RANGE(CM_RECENT_BUILD_ITEM, CM_RECENT_BUILD_ITEM + CM_MAX_RECENT_PATHS, CMakeSetupFrm::OnRecentFileMenu)
EVT_TEXT_ENTER(ID_SEARCHQUERY, CMakeSetupFrm::OnAddQuery )
END_EVENT_TABLE()
/** Callback function for CMake generator, to tell user how
far the generation actually is */
void updateProgress(const char *msg, float prog, void *cd)
{
// TODO: Make some kind of progress counter
CMakeSetupFrm *fm = (CMakeSetupFrm *)cd;
if(fm)
{
if(prog < 0)
fm->LogMessage(0, msg);
else
{
fm->UpdateProgress(prog);
fm->IssueUpdate();
}
}
}
/** Callback function for CMake generator, to tell user about stuff. This should be
logged in the m_log window */
void MFCMessageCallback(const char* m, const char* title, bool& nomore, void *clientdata)
{
CMakeSetupFrm *fm = (CMakeSetupFrm *)clientdata;
if(fm)
{
wxString what = m, msg;
if(what.StartsWith("CMake Error: "))
fm->LogMessage(-1, m);
else
fm->LogMessage(1, m);
}
}
// Convert to Win32 path (slashes). This calls the system tools one and then
// removes the spaces. It is not in system tools because we don't want any
// generators accidentally use it
std::string ConvertToWindowsPath(const char* path)
{
// Convert to output path.
// Remove the "" around it (if any) since it's an output path for
// the shell. If another shell-oriented feature is not designed
// for a GUI use, then we are in trouble.
// save the value of the force to unix path option
bool saveForce = cmSystemTools::GetForceUnixPaths();
// make sure we get windows paths no matter what for the GUI
cmSystemTools::SetForceUnixPaths(false);
std::string s = cmSystemTools::ConvertToOutputPath(path);
// now restore the force unix path to its previous value
cmSystemTools::SetForceUnixPaths(saveForce);
if (s.size())
{
std::string::iterator i = s.begin();
if (*i == '\"')
{
s.erase(i, i + 1);
}
i = s.begin() + s.length() - 1;
if (*i == '\"')
{
s.erase(i, i + 1);
}
}
return s;
}
bool DnDFile::OnDropFiles(wxCoord, wxCoord, const wxArrayString& filenames)
{
size_t nFiles = filenames.GetCount();
// only one item allowed
if(nFiles > 1)
return false;
if(nFiles == 1)
{
// only one dir allowed
if(!wxDirExists(filenames[0]))
return false;
// strip the seperator
wxFileName name;
name.AssignDir(filenames[0]);
// issue a 'drop' by changing text ctrl
m_pOwner->SetValue(name.GetFullPath());
return true;
}
return false;
}
/*!
* CMakeSetupFrm constructors
*/
CMakeSetupFrm::CMakeSetupFrm( )
: m_cmake(0)
{
}
CMakeSetupFrm::CMakeSetupFrm( wxWindow* parent, wxWindowID id, const wxString& caption, const wxPoint& pos, const wxSize& size, long style )
: m_cmake(0)
{
Create( parent, id, caption, pos, size, style );
}
/*!
* CMakeSetupFrm creator
*/
bool CMakeSetupFrm::Create( wxWindow* parent, wxWindowID id, const wxString& caption, const wxPoint& pos, const wxSize& size, long style )
{
////@begin CMakeSetupFrm member initialisation
m_splitter = NULL;
m_cmProjectPath = NULL;
m_BrowseProjectPathButton = NULL;
m_cmBuildPath = NULL;
m_BrowseSourcePathButton = NULL;
m_cmGeneratorChoice = NULL;
m_cmSearchQuery = NULL;
m_cmShowAdvanced = NULL;
m_cmOptions = NULL;
m_cmLog = NULL;
m_cmDescription = NULL;
m_ConfigureButton = NULL;
m_OkButton = NULL;
m_CancelButton = NULL;
m_DeleteCacheButton = NULL;
m_ClearLogButton = NULL;
m_cmBrowseCell = NULL;
////@end CMakeSetupFrm member initialisation
wxFrame::Create( parent, id, caption, pos, size, style );
// make sure the developer does not assign more then 100
// would be rediculous but also overlap other id's
wxASSERT(CM_MAX_RECENT_PATHS < 100);
m_ExitTimer = 0;
m_progressDlg = 0;
m_noRefresh = false;
m_quitAfterGenerating = false;
m_config = new wxConfig("CMakeSetup");
wxIcon icon(CMakeIcon_xpm);
SetIcon(icon);
CreateControls();
//SetIcon(GetIconResource(wxT("cmake_icon.xpm")));
//SetIcon(wxIcon("NGDialog.ico", wxBITMAP_TYPE_ICO_RESOURCE));
Centre();
// is it needed to hide console?
m_RunningConfigure = false;
cmSystemTools::SetRunCommandHideConsole(true);
cmSystemTools::SetErrorCallback(MFCMessageCallback, (void *)this);
// create our cmake instance
m_cmake = new cmake;
m_cmake->SetProgressCallback(updateProgress, (void *)this);
return TRUE;
}
CMakeSetupFrm::~CMakeSetupFrm()
{
wxString str;
// write configs back to disk
m_config->Write(CM_LASTPROJECT_PATH, m_cmProjectPath->GetValue());
m_config->Write(CM_LASTBUILD_PATH, m_cmBuildPath->GetValue());
// clear the config first
for(size_t i = 0 ; i < CM_MAX_RECENT_PATHS; i++)
{
str.Printf("%s%i", _(CM_RECENT_BUILD_PATH), i);
m_config->Write(str, _(""));
}
// write the last CM_MAX_RECENT_PATHS items back to config
int i = (m_recentPaths.Count() >= CM_MAX_RECENT_PATHS ? CM_MAX_RECENT_PATHS : m_recentPaths.Count());
while(i > 0)
{
str.Printf("%s%i", _(CM_RECENT_BUILD_PATH), i);
m_config->Write(str, m_recentPaths[i - 1]);
i--;
}
// write recent query list to config
for(int j = 0; j < m_cmSearchQuery->GetCount(); j++)
{
// allow max to be written
if(j < CM_MAX_SEARCH_QUERIES)
{
str.Printf("%s%i", _(CM_SEARCH_QUERY), j);
m_config->Write(str, m_cmSearchQuery->GetString(j));
}
else
break;
}
// set window pos + size in settings
if(!IsIconized() && !IsMaximized())
{
int xsize, ysize;
GetSize(&xsize, &ysize);
if(xsize > 0 && ysize > 0)
{
m_config->Write(CM_XSIZE, (long)xsize);
m_config->Write(CM_YSIZE, (long)ysize);
}
if(m_splitter->GetSashPosition() > 0)
m_config->Write(CM_SPLITTERPOS, (long)m_splitter->GetSashPosition());
GetPosition(&xsize, &ysize);
if(xsize != 0 && ysize != 0)
{
m_config->Write(CM_XPOS, (long)xsize);
m_config->Write(CM_YPOS, (long)ysize);
}
}
// write changes (will be done before deletion)
delete m_config;
// delete timer
if(m_ExitTimer)
delete m_ExitTimer;
// delete our cmake instance again
if(m_cmake)
delete m_cmake;
}
void CMakeSetupFrm::UpdateWindowState()
{
bool dogenerate = !m_RunningConfigure && !m_cmOptions->IsCacheDirty() &&
(m_cmOptions->GetCount() != 0);
// when configure is running, disable a lot of stuff
m_cmProjectPath->Enable(!m_RunningConfigure);
m_BrowseProjectPathButton->Enable(!m_RunningConfigure);
m_cmBuildPath->Enable(!m_RunningConfigure);
m_BrowseSourcePathButton->Enable(!m_RunningConfigure);
m_cmGeneratorChoice->Enable(!m_RunningConfigure);
m_cmShowAdvanced->Enable(!m_RunningConfigure);
m_cmOptions->Enable(!m_RunningConfigure);
m_ConfigureButton->Enable(!m_RunningConfigure);
m_OkButton->Enable(dogenerate);
m_CancelButton->Enable(m_RunningConfigure);
m_DeleteCacheButton->Enable(!m_RunningConfigure);
m_ClearLogButton->Enable(!m_RunningConfigure);
if(m_RunningConfigure)
m_cmBrowseCell->Enable(false);
// when cache loaded (items available show other control)
m_cmGeneratorChoice->Enable(m_cmOptions->GetCount() == 0 && !m_RunningConfigure);
m_cmSearchQuery->Enable(!m_RunningConfigure);
m_cmBrowseCell->Enable(!m_RunningConfigure && m_cmOptions->IsSelectedItemBrowsable());
// disable the menus when configuring
if(GetMenuBar())
{
// disable configure button when there is nothing, and generate and exit
// only when it is allowed to generate
GetMenuBar()->Enable(ID_MENU_EXITGENERATE, dogenerate);
GetMenuBar()->Enable(ID_MENU_CONFIGURE, !m_RunningConfigure);
for(size_t i = 0; i < GetMenuBar()->GetMenuCount(); i++)
GetMenuBar()->EnableTop(i, !m_RunningConfigure);
}
}
void CMakeSetupFrm::LogMessage(int logkind, const char *msg)
{
// put CR first but prevent a CR at the end
#ifndef __LINUX__
if(m_cmLog->IsModified())
(*m_cmLog) << wxT("\n");
#else
// Linux requires a different approach
if(!m_cmLog->GetValue().IsEmpty())
(*m_cmLog) << wxT("\n");
#endif
// log error, warning, or message
wxTextAttr defattr = m_cmLog->GetDefaultStyle();
switch(logkind)
{
// user message
case 1:
{
wxTextAttr colattr(*wxBLUE);
m_cmLog->SetDefaultStyle(colattr);
(*m_cmLog) << msg;
m_cmLog->SetDefaultStyle(defattr);
}
break;
// progress
case 0:
(*m_cmLog) << msg;
break;
// error
case -1:
{
wxTextAttr colattr(*wxRED);
m_cmLog->SetDefaultStyle(colattr);
(*m_cmLog) << msg;
m_cmLog->SetDefaultStyle(defattr);
}
break;
}
IssueUpdate();
}
void CMakeSetupFrm::IssueUpdate()
{
//::wxSafeYield(m_CancelButton, true);
::wxYield();
// when we pressed cancel on the progress dialog
// stop all activities
if(m_progressDlg)
{
if(m_progressDlg->CancelPressed() && !m_progressDlg->IsCancelling())
{
m_progressDlg->CancelAcknowledged();
// send a button event to cancel the progress
wxCommandEvent event( wxEVT_COMMAND_BUTTON_CLICKED, ID_DO_CANCEL);
wxPostEvent(this, event);
}
}
}
/*!
* Control creation for CMakeSetupFrm
*/
void CMakeSetupFrm::CreateControls()
{
////@begin CMakeSetupFrm content construction
CMakeSetupFrm* itemFrame1 = this;
wxMenuBar* menuBar = new wxMenuBar;
wxMenu* itemMenu37 = new wxMenu;
itemMenu37->Append(ID_MENU_RELOAD_CACHE, _("&Reload Cache\tCtrl+R"), _("Reload the cache from disk"), wxITEM_NORMAL);
itemMenu37->Append(ID_MENU_DELETE_CACHE, _("&Delete Cache\tCtrl+D"), _("Delete the cache on disk of the current path"), wxITEM_NORMAL);
itemMenu37->AppendSeparator();
itemMenu37->Append(ID_MENU_QUIT, _("E&xit\tAlt+F4"), _("Quit CMake Setup"), wxITEM_NORMAL);
menuBar->Append(itemMenu37, _("&File"));
wxMenu* itemMenu42 = new wxMenu;
itemMenu42->Append(ID_MENU_CONFIGURE, _("&Configure\tCtrl+N"), _T(""), wxITEM_NORMAL);
itemMenu42->Append(ID_MENU_EXITGENERATE, _("&Generate and Exit\tCtrl+G"), _T(""), wxITEM_NORMAL);
itemMenu42->Append(ID_MENU_TOGGLE_ADVANCED, _("Toggle &Advanced\tCtrl+A"), _T(""), wxITEM_NORMAL);
itemMenu42->AppendSeparator();
itemMenu42->Append(ID_CMAKE_OPTIONS, _("&Options\tCtrl+O"), _T(""), wxITEM_NORMAL);
menuBar->Append(itemMenu42, _("&Tools"));
wxMenu* itemMenu48 = new wxMenu;
itemMenu48->Append(ID_ABOUTDLG, _("&About ..."), _("Shows the about dialog ..."), wxITEM_NORMAL);
menuBar->Append(itemMenu48, _("&Help"));
itemFrame1->SetMenuBar(menuBar);
m_splitter = new wxSplitterWindow( itemFrame1, ID_SPLITTERWINDOW, wxDefaultPosition, wxSize(100, 100), wxSP_3DBORDER|wxSP_3DSASH|wxNO_BORDER );
wxPanel* itemPanel3 = new wxPanel( m_splitter, ID_MAINPANEL, wxDefaultPosition, wxSize(600, 400), wxNO_BORDER|wxTAB_TRAVERSAL );
itemPanel3->SetExtraStyle(itemPanel3->GetExtraStyle()|wxWS_EX_VALIDATE_RECURSIVELY);
wxBoxSizer* itemBoxSizer4 = new wxBoxSizer(wxVERTICAL);
itemPanel3->SetSizer(itemBoxSizer4);
wxBoxSizer* itemBoxSizer5 = new wxBoxSizer(wxHORIZONTAL);
itemBoxSizer4->Add(itemBoxSizer5, 0, wxGROW|wxTOP|wxBOTTOM, 5);
wxFlexGridSizer* itemFlexGridSizer6 = new wxFlexGridSizer(2, 3, 0, 0);
itemFlexGridSizer6->AddGrowableRow(1);
itemFlexGridSizer6->AddGrowableCol(1);
itemBoxSizer5->Add(itemFlexGridSizer6, 1, wxALIGN_TOP|wxLEFT, 5);
wxStaticText* itemStaticText7 = new wxStaticText( itemPanel3, wxID_STATIC, _("CMake project path"), wxDefaultPosition, wxDefaultSize, 0 );
itemFlexGridSizer6->Add(itemStaticText7, 0, wxALIGN_LEFT|wxALIGN_CENTER_VERTICAL|wxLEFT|wxRIGHT|wxADJUST_MINSIZE, 5);
m_cmProjectPath = new wxTextCtrl( itemPanel3, ID_PROJECT_PATH, _T(""), wxDefaultPosition, wxSize(50, -1), 0 );
itemFlexGridSizer6->Add(m_cmProjectPath, 1, wxGROW|wxALIGN_CENTER_VERTICAL|wxTOP|wxBOTTOM, 5);
m_BrowseProjectPathButton = new wxButton( itemPanel3, ID_BROWSE_PROJECT, _("Browse"), wxDefaultPosition, wxSize(55, -1), 0 );
itemFlexGridSizer6->Add(m_BrowseProjectPathButton, 0, wxALIGN_CENTER_HORIZONTAL|wxALIGN_CENTER_VERTICAL|wxALL, 5);
wxStaticText* itemStaticText10 = new wxStaticText( itemPanel3, wxID_STATIC, _("Project build path"), wxDefaultPosition, wxDefaultSize, 0 );
itemFlexGridSizer6->Add(itemStaticText10, 0, wxALIGN_LEFT|wxALIGN_CENTER_VERTICAL|wxLEFT|wxRIGHT|wxADJUST_MINSIZE, 5);
m_cmBuildPath = new wxTextCtrl( itemPanel3, ID_SOURCE_BUILD_PATH, _T(""), wxDefaultPosition, wxSize(50, -1), 0 );
itemFlexGridSizer6->Add(m_cmBuildPath, 1, wxGROW|wxALIGN_TOP|wxTOP|wxBOTTOM, 5);
m_BrowseSourcePathButton = new wxButton( itemPanel3, ID_BROWSE_BUILD, _("Browse"), wxDefaultPosition, wxSize(55, -1), 0 );
itemFlexGridSizer6->Add(m_BrowseSourcePathButton, 0, wxALIGN_CENTER_HORIZONTAL|wxALIGN_CENTER_VERTICAL|wxALL, 5);
wxBoxSizer* itemBoxSizer13 = new wxBoxSizer(wxVERTICAL);
itemBoxSizer5->Add(itemBoxSizer13, 0, wxGROW|wxLEFT|wxRIGHT, 5);
wxFlexGridSizer* itemFlexGridSizer14 = new wxFlexGridSizer(2, 2, 0, 0);
itemBoxSizer13->Add(itemFlexGridSizer14, 0, wxALIGN_CENTER_HORIZONTAL|wxLEFT|wxRIGHT, 5);
wxStaticText* itemStaticText15 = new wxStaticText( itemPanel3, wxID_STATIC, _("Generate"), wxDefaultPosition, wxDefaultSize, 0 );
itemFlexGridSizer14->Add(itemStaticText15, 0, wxALIGN_LEFT|wxALIGN_CENTER_VERTICAL|wxRIGHT|wxADJUST_MINSIZE, 5);
wxString* m_cmGeneratorChoiceStrings = NULL;
m_cmGeneratorChoice = new wxComboBox( itemPanel3, ID_CHOOSE_GENERATOR, _T(""), wxDefaultPosition, wxSize(170, -1), 0, m_cmGeneratorChoiceStrings, wxCB_READONLY );
itemFlexGridSizer14->Add(m_cmGeneratorChoice, 1, wxALIGN_CENTER_HORIZONTAL|wxGROW|wxTOP|wxBOTTOM, 5);
wxStaticText* itemStaticText17 = new wxStaticText( itemPanel3, wxID_STATIC, _("Search"), wxDefaultPosition, wxDefaultSize, 0 );
itemFlexGridSizer14->Add(itemStaticText17, 0, wxALIGN_LEFT|wxALIGN_CENTER_VERTICAL|wxRIGHT|wxADJUST_MINSIZE, 5);
wxString* m_cmSearchQueryStrings = NULL;
m_cmSearchQuery = new wxComboBox( itemPanel3, ID_SEARCHQUERY, _T(""), wxDefaultPosition, wxSize(170, -1), 0, m_cmSearchQueryStrings, wxWANTS_CHARS );
itemFlexGridSizer14->Add(m_cmSearchQuery, 1, wxALIGN_CENTER_HORIZONTAL|wxGROW|wxTOP|wxBOTTOM, 5);
m_cmShowAdvanced = new wxCheckBox( itemPanel3, ID_SHOW_ADVANCED, _("Show advanced values"), wxDefaultPosition, wxDefaultSize, wxCHK_2STATE );
m_cmShowAdvanced->SetValue(FALSE);
itemBoxSizer13->Add(m_cmShowAdvanced, 0, wxALIGN_RIGHT|wxLEFT|wxRIGHT, 5);
m_cmOptions = new wxPropertyList( itemPanel3, ID_OPTIONS, wxDefaultPosition, wxSize(200, 150), wxSTATIC_BORDER|wxWANTS_CHARS|wxVSCROLL );
m_cmOptions->SetDefaultColSize(250);
m_cmOptions->SetDefaultRowSize(25);
m_cmOptions->SetColLabelSize(20);
m_cmOptions->SetRowLabelSize(0);
m_cmOptions->CreateGrid(10, 2, wxGrid::wxGridSelectRows);
itemBoxSizer4->Add(m_cmOptions, 1, wxGROW|wxALL, 5);
wxPanel* itemPanel21 = new wxPanel( m_splitter, ID_LOGPANEL, wxDefaultPosition, wxSize(-1, 100), wxNO_BORDER|wxTAB_TRAVERSAL );
wxBoxSizer* itemBoxSizer22 = new wxBoxSizer(wxVERTICAL);
itemPanel21->SetSizer(itemBoxSizer22);
wxBoxSizer* itemBoxSizer23 = new wxBoxSizer(wxHORIZONTAL);
itemBoxSizer22->Add(itemBoxSizer23, 1, wxGROW|wxLEFT|wxRIGHT|wxTOP, 5);
m_cmLog = new wxTextCtrl( itemPanel21, ID_LOG_AREA, _("Select your project path (where CMakeLists.txt is) and then select the build path (where the projects should be saved), or select a previous build path.\n\nRight click on a cache value for additional options (delete and ignore). Press configure to update and display new values in red, press OK to generate the projects and exit."), wxDefaultPosition, wxDefaultSize, wxTE_MULTILINE|wxTE_READONLY|wxTE_RICH2|wxSTATIC_BORDER );
itemBoxSizer23->Add(m_cmLog, 1, wxGROW|wxRIGHT, 5);
m_cmDescription = new wxTextCtrl( itemPanel21, ID_DESCRIPTION, _T(""), wxDefaultPosition, wxSize(200, -1), wxTE_MULTILINE|wxTE_READONLY|wxTE_RICH2|wxSTATIC_BORDER );
itemBoxSizer23->Add(m_cmDescription, 0, wxGROW|wxLEFT, 5);
wxBoxSizer* itemBoxSizer26 = new wxBoxSizer(wxHORIZONTAL);
itemBoxSizer22->Add(itemBoxSizer26, 0, wxALIGN_CENTER_HORIZONTAL|wxALL, 5);
m_ConfigureButton = new wxButton( itemPanel21, ID_DO_CONFIGURE, _("Co&nfigure"), wxDefaultPosition, wxDefaultSize, 0 );
m_ConfigureButton->SetDefault();
itemBoxSizer26->Add(m_ConfigureButton, 0, wxALIGN_CENTER_VERTICAL|wxALL, 5);
m_OkButton = new wxButton( itemPanel21, ID_DO_OK, _("&Generate!"), wxDefaultPosition, wxDefaultSize, 0 );
itemBoxSizer26->Add(m_OkButton, 0, wxALIGN_CENTER_VERTICAL|wxALL, 5);
m_CancelButton = new wxButton( itemPanel21, ID_DO_CANCEL, _("C&ancel"), wxDefaultPosition, wxDefaultSize, 0 );
itemBoxSizer26->Add(m_CancelButton, 0, wxALIGN_CENTER_VERTICAL|wxALL, 5);
#if defined(__WXMSW__)
wxStaticLine* itemStaticLine30 = new wxStaticLine( itemPanel21, wxID_STATIC, wxDefaultPosition, wxDefaultSize, wxLI_HORIZONTAL );
itemBoxSizer26->Add(itemStaticLine30, 0, wxGROW|wxALL, 5);
#endif
m_DeleteCacheButton = new wxButton( itemPanel21, ID_DO_DELETE_CACHE, _("&Delete Cache"), wxDefaultPosition, wxDefaultSize, 0 );
itemBoxSizer26->Add(m_DeleteCacheButton, 0, wxALIGN_CENTER_VERTICAL|wxALL, 5);
m_ClearLogButton = new wxButton( itemPanel21, ID_CLEAR_LOG, _("Clear &Log"), wxDefaultPosition, wxDefaultSize, 0 );
itemBoxSizer26->Add(m_ClearLogButton, 0, wxALIGN_CENTER_VERTICAL|wxALL, 5);
#if defined(__WXMSW__)
wxStaticLine* itemStaticLine33 = new wxStaticLine( itemPanel21, wxID_STATIC, wxDefaultPosition, wxDefaultSize, wxLI_HORIZONTAL );
itemBoxSizer26->Add(itemStaticLine33, 0, wxGROW|wxALL, 5);
#endif
m_cmBrowseCell = new wxButton( itemPanel21, ID_BROWSE_GRID, _("&Browse"), wxDefaultPosition, wxDefaultSize, 0 );
itemBoxSizer26->Add(m_cmBrowseCell, 0, wxALIGN_CENTER_VERTICAL|wxALL, 5);
m_splitter->SplitHorizontally(itemPanel3, itemPanel21, 300);
wxStatusBar* itemStatusBar35 = new wxStatusBar( itemFrame1, ID_STATUSBAR, wxST_SIZEGRIP|wxNO_BORDER );
itemStatusBar35->SetFieldsCount(2);
itemFrame1->SetStatusBar(itemStatusBar35);
////@end CMakeSetupFrm content construction
}
void CMakeSetupFrm::DoInitFrame(cmCommandLineInfo &cm, const wxString &fn)
{
// path to where cmake.exe is
// m_PathToExecutable = cm.GetPathToExecutable().c_str();
m_PathToExecutable = fn;
// adjust size of last bar, to display % progress
wxStatusBar *bar = GetStatusBar();
if(bar)
{
wxASSERT(bar->GetFieldsCount() > 1);
// fill all with -1. Why this way? because the count of the status bars
// can change. All of the widths must be accounted for and initialised
int *widths = new int[bar->GetFieldsCount()];
for(int i = 0; i < bar->GetFieldsCount(); i++)
widths[i] = -1;
// the % field
widths[1] = 75;
bar->SetStatusWidths(bar->GetFieldsCount(), widths);
delete widths;
}
wxString name, generator;
std::vector<std::string> names;
m_RunningConfigure = false;
// set grid labels
m_cmOptions->SetColLabelValue(0, wxT("Cache Name"));
m_cmOptions->SetColLabelValue(1, wxT("Cache Value"));
m_cmOptions->SetProjectGenerated(false);
// set drop target
m_cmOptions->SetDropTarget(new DnDFile(m_cmBuildPath));
m_cmake->GetRegisteredGenerators(names);
for(std::vector<std::string>::iterator i = names.begin(); i != names.end(); ++i)
{
name = i->c_str();
m_cmGeneratorChoice->Append(name);
}
// sync advanced option with grid
m_cmOptions->SetShowAdvanced(m_cmShowAdvanced->GetValue());
// if we have a command line query that a generator
// needs to be chosen instead of the default, take it
bool foundGivenGenerator = false;
if(!cm.m_GeneratorChoiceString.IsEmpty())
{
// set proper discovered generator
foundGivenGenerator = m_cmGeneratorChoice->SetStringSelection(cm.m_GeneratorChoiceString);
}
// if none selected, we will see if VS8, VS7 or VS6 is present
if(!foundGivenGenerator || m_cmGeneratorChoice->GetValue().IsEmpty())
{
std::string mp;
mp = "[HKEY_LOCAL_MACHINE\\SOFTWARE\\Microsoft\\VisualStudio\\8.0\\Setup;Dbghelp_path]";
cmSystemTools::ExpandRegistryValues(mp);
if(mp != "/registry")
generator = wxT("Visual Studio 8 2005");
else
{
mp = "[HKEY_LOCAL_MACHINE\\SOFTWARE\\Microsoft\\VisualStudio\\7.1;InstallDir]";
cmSystemTools::ExpandRegistryValues(mp);
if (mp != "/registry")
generator = wxT("Visual Studio 7 .NET 2003");
else
{
mp = "[HKEY_LOCAL_MACHINE\\SOFTWARE\\Microsoft\\VisualStudio\\7.0;InstallDir]";
cmSystemTools::ExpandRegistryValues(mp);
if (mp != "/registry")
generator = wxT("Visual Studio 7");
else
generator = wxT("Visual Studio 6");
}
}
}
// set proper discovered generator
m_cmGeneratorChoice->SetStringSelection(generator);
wxString str;
//str.Printf("CMake %d.%d - %s", cmake::GetMajorVersion(), cmake::GetMinorVersion(), cmake::GetReleaseVersion());
str.Printf("CMakeSetup v%i.%i%s", CMAKEGUI_MAJORVER, CMAKEGUI_MINORVER, CMAKEGUI_ADDVER);
SetTitle(str);
wxString path;
// get last 5 used projects
for(size_t i = 0; i < CM_MAX_RECENT_PATHS; i++)
{
path.Printf("%s%i", _(CM_RECENT_BUILD_PATH), i);
if(m_config->Read(path, &str))
AppendPathToRecentList(str);
}
// get query items
for(size_t i = 0; i < CM_MAX_SEARCH_QUERIES; i++)
{
path.Printf("%s%i", _(CM_SEARCH_QUERY), i);
if(m_config->Read(path, &str))
m_cmSearchQuery->Append(str);
}
// make sure the call to update grid is not executed
m_noRefresh = true;
m_cmSearchQuery->SetValue(_(""));
m_noRefresh = false;
// Get the parameters from the command line info
// If an unknown parameter is found, try to interpret it too, since it
// is likely to be a file dropped on the shortcut :)
bool sourceDirLoaded = false,
buildDirLoaded = false;
if(cm.m_LastUnknownParameter.empty())
{
if(cm.m_WhereSource.size() > 0 )
{
m_cmProjectPath->SetValue(cm.m_WhereSource.c_str());
sourceDirLoaded = true;
}
if (cm.m_WhereBuild.size() > 0 )
{
m_cmBuildPath->SetValue(cm.m_WhereBuild.c_str());
buildDirLoaded = true;
}
m_cmShowAdvanced->SetValue(cm.m_AdvancedValues);
}
else
{
m_cmShowAdvanced->SetValue(false);
// TODO: Interpret directory from dropped shortcut
//this->ChangeDirectoriesFromFile(cmdInfo->m_LastUnknownParameter.c_str());
}
if (cm.m_ExitAfterLoad)
{
int id = GetId();
m_ExitTimer = new wxTimer(this, id);
m_ExitTimer->Start(3000);
Connect( id, wxEVT_TIMER,(wxObjectEventFunction) &CMakeSetupFrm::OnExitTimer );
}
// retrieve settings, this needs to be done here
// because writing to the m_cmBuildPath triggers a cache reload
if(!sourceDirLoaded && m_config->Read(CM_LASTPROJECT_PATH, &str))
m_cmProjectPath->SetValue(str);
if(!buildDirLoaded)
{
m_cmOptions->RemoveAll();
if(m_config->Read(CM_LASTBUILD_PATH, &str))
m_cmBuildPath->SetValue(str);
}
// set window size from settings
long xsize, ysize, splitpos;
if(m_config->Read(CM_XSIZE, &xsize) && m_config->Read(CM_YSIZE, &ysize) &&
m_config->Read(CM_SPLITTERPOS, &splitpos))
{
SetSize(xsize, ysize);
m_splitter->SetSashPosition(splitpos);
}
if(m_config->Read(CM_XPOS, &xsize) && m_config->Read(CM_YPOS, &ysize))
SetSize(xsize, ysize, -1, -1, wxSIZE_USE_EXISTING);
UpdateWindowState();
}
void CMakeSetupFrm::LoadCacheFromDiskToGUI()
{
wxString builddir = m_cmBuildPath->GetValue();
cmCacheManager *cachem = m_cmake->GetCacheManager();
if(cachem && !builddir.Trim().IsEmpty())
{
if(cachem->LoadCache(builddir.c_str()))
AppendPathToRecentList(builddir);
// represent this cache in the grid, but not before we
// wiped all of the old items
FillCacheGUIFromCacheManager();
// set the generator string to the one used in the cache
cmCacheManager::CacheIterator it = cachem->GetCacheIterator("CMAKE_GENERATOR");
if(!it.IsAtEnd())
{
wxString curGen = it.GetValue();
m_cmGeneratorChoice->SetStringSelection(curGen);
}
}
}
void CMakeSetupFrm::AppendPathToRecentList(const wxString &p)
{
wxFileName path;
wxString str;
if(p.IsEmpty())
return;
// cheap way to get rid of trailing seperators
path.AssignDir(p);
str = path.GetPath();
// append the item, or add it to end to make sure
// it is remembered between sessions
for(size_t i = 0; i < m_recentPaths.Count(); i++)
{
if(m_recentPaths[i].IsSameAs(str, false))
{
m_recentPaths.RemoveAt(i);
// only re-add when item is still valid
if(::wxDirExists(str))
m_recentPaths.Add(str);
else
return; // no add when the item is not existing
return;
}
}
if(GetMenuBar())
{
// get file menu
int lastUsedID = 0;
wxMenu *mnu = GetMenuBar()->GetMenu(0);
wxASSERT(mnu != 0);
if(::wxDirExists(str))
{
// add to array
if(m_recentPaths.Count() == 0)
mnu->AppendSeparator();
lastUsedID = CM_RECENT_BUILD_ITEM + m_recentPaths.Count();
m_recentPaths.Add(str);
// when we have more in list then we can display, prune and
// remove some menu items until we have room (and available ID's again)
if(m_recentPaths.Count() > CM_MAX_RECENT_PATHS)
{
// prune the list
while(m_recentPaths.Count() > CM_MAX_RECENT_PATHS)
m_recentPaths.RemoveAt(0);
// now determine count, and remove until we have room
int index = mnu->GetMenuItemCount() - 1;
int count = 0;
wxASSERT(index > 0);
wxMenuItem *item;
do
{
item = mnu->FindItemByPosition(index);
if(item)
{
if(item->IsSeparator())
{
// next index is valid item
index ++;
break;
}
else
count ++;
}
index --;
}
while(index >= 0 && item);
// ok, if count > CM_MAX_RECENT_PATHS then we are going to
// delete some items on the index position
if(count >= CM_MAX_RECENT_PATHS)
{
// delete items that are exceeding
while(count >= CM_MAX_RECENT_PATHS)
{
lastUsedID = mnu->FindItemByPosition(index)->GetId();
mnu->Delete(lastUsedID);
count --;
}
}
}
// append item
mnu->Append(lastUsedID, str);
}
}
}
bool CMakeSetupFrm::PerformCacheRun()
{
bool enable = false;
cmCacheManager *cachem = m_cmake->GetCacheManager();
cmCacheManager::CacheIterator it = cachem->NewIterator();
// remove all items that are no longer present
size_t j = 0;
while(j < m_cmOptions->GetCount())
{
// check to see if it is still in the CMake cache
// if it is still in the cache then it is no longer new
wxPropertyItem *item = m_cmOptions->GetItem(j);
if ( !it.Find((const char*)item->GetPropName().c_str()) )
m_cmOptions->RemoveProperty(item);
else
{
// ok we found it, mark as old
item->SetNewValue(false);
int row = m_cmOptions->FindProperty(item);
if(row != -1)
m_cmOptions->UpdatePropertyItem(item, row);
j++;
}
}
if(cachem->GetSize() > 0 && !cmSystemTools::GetErrorOccuredFlag())
{
bool enable = true;
for(size_t i = 0; i < m_cmOptions->GetCount(); i++)
{
wxPropertyItem* item = m_cmOptions->GetItem(i);
if(item->GetAdvanced())
{
if(item->GetNewValue() && m_cmOptions->GetShowAdvanced())
{
// if one new value then disable to OK button
enable = false;
break;
}
}
else
{
if(item->GetNewValue())
{
// if one new value then disable to OK button
enable = false;
break;
}
}
}
}
return enable;
}
void CMakeSetupFrm::FillCacheGUIFromCacheManager()
{
cmCacheManager *cachem = m_cmake->GetCacheManager();
cmCacheManager::CacheIterator it = cachem->NewIterator();
// remove all items that are no longer present
size_t j = 0;
while(j < m_cmOptions->GetCount())
{
// check to see if it is still in the CMake cache
// if it is still in the cache then it is no longer new
wxPropertyItem *item = m_cmOptions->GetItem(j);
if ( !it.Find((const char*)item->GetPropName().c_str()) )
m_cmOptions->RemoveProperty(item);
else
j++;
}
// if there are already entries in the cache, then
// put the new ones in the top, so they show up first
bool reverseOrder = false;
for(cmCacheManager::CacheIterator i = cachem->NewIterator(); !i.IsAtEnd(); i.Next())
{
const char* key = i.GetName();
// if value has trailing space or tab, enclose it in single quotes
// to enforce the fact that it has 'invisible' trailing stuff
std::string value = i.GetValue();
if (value.size() && (value[value.size() - 1] == ' ' || value[value.size() - 1] == '\t'))
value = '\'' + value + '\'';
bool advanced = i.GetPropertyAsBool("ADVANCED");
switch(i.GetType() )
{
case cmCacheManager::BOOL:
{
wxString OnOff;
if(cmSystemTools::IsOn(value.c_str()))
OnOff = wxT("ON");
else
OnOff = wxT("OFF");
m_cmOptions->AddProperty(key,
OnOff.c_str(),
i.GetProperty("HELPSTRING"),
wxPropertyList::CHECKBOX, "ON|OFF",
reverseOrder,
advanced );
}
break;
case cmCacheManager::PATH:
m_cmOptions->AddProperty(key,
value.c_str(),
i.GetProperty("HELPSTRING"),
wxPropertyList::PATH,"",
reverseOrder, advanced);
break;
case cmCacheManager::FILEPATH:
m_cmOptions->AddProperty(key,
value.c_str(),
i.GetProperty("HELPSTRING"),
wxPropertyList::FILE,"",
reverseOrder, advanced);
break;
case cmCacheManager::STRING:
m_cmOptions->AddProperty(key,
value.c_str(),
i.GetProperty("HELPSTRING"),
wxPropertyList::EDIT,"",
reverseOrder, advanced);
break;
case cmCacheManager::INTERNAL:
{
wxPropertyItem *pItem = m_cmOptions->FindPropertyByName(key);
if(pItem)
m_cmOptions->RemoveProperty(pItem);
}
break;
}
}
}
void CMakeSetupFrm::OnExitTimer(wxTimerEvent &event)
{
Close();
}
/*!
* wxEVT_COMMAND_BUTTON_CLICKED event handler for ID_BROWSE_PROJECT
*/
void CMakeSetupFrm::OnButtonBrowseProject( wxCommandEvent& event )
{
const wxString& dir = wxDirSelector("Select project directory", m_cmProjectPath->GetValue());
if(!dir.IsEmpty())
m_cmProjectPath->SetValue(dir);
}
/*!
* wxEVT_COMMAND_BUTTON_CLICKED event handler for ID_BROWSE_BUILD
*/
void CMakeSetupFrm::OnButtonBrowseBuild( wxCommandEvent& event )
{
const wxString& dir = wxDirSelector("Select build directory", m_cmBuildPath->GetValue());
if(!dir.IsEmpty())
m_cmBuildPath->SetValue(dir);
}
/*!
* wxEVT_COMMAND_CHECKBOX_CLICKED event handler for ID_SHOW_ADVANCED
*/
void CMakeSetupFrm::OnShowAdvancedValues( wxCommandEvent& event )
{
if(m_cmShowAdvanced->GetValue())
m_cmOptions->ShowAdvanced();
else
m_cmOptions->HideAdvanced();
}
/*!
* wxEVT_COMMAND_BUTTON_CLICKED event handler for ID_DO_CONFIGURE
*/
void CMakeSetupFrm::OnButtonConfigure( wxCommandEvent& event )
{
DoConfigure();
}
void CMakeSetupFrm::DoConfigure()
{
// enable error messages each time configure is pressed
cmSystemTools::EnableMessages();
m_cmOptions->HideControls();
cmSystemTools::ResetErrorOccuredFlag();
// instantiate a dialog for the progress meter
PerformCacheRun();
RunCMake(false);
}
int CMakeSetupFrm::RunCMake(bool generateProjectFiles)
{
int value = -1;
// clear log
m_cmLog->Clear();
m_cmLog->DiscardEdits();
wxString builddir = m_cmBuildPath->GetValue(),
sourcedir = m_cmProjectPath->GetValue(),
err = wxT("Error in configuration process, project files may be invalid");
// sanity check for people pressing OK on empty dirs
if(builddir.Trim().IsEmpty() || sourcedir.Trim().IsEmpty())
{
wxMessageBox(wxT("Please enter a valid source directory and build directory"), wxT("Error"), wxOK | wxICON_ERROR, this);
return -1;
}
// check if the directory exists, if not, create it
if(!cmSystemTools::FileExists(builddir.c_str()))
{
wxString str;
str << wxT("Build directory does not exist, should I create it?\n\nDirectory: ") << builddir;
int answer = wxMessageBox(str, wxT("Create directory"), wxYES_NO, this);
if (answer == wxYES)
{
if(!cmSystemTools::MakeDirectory(builddir.c_str()))
{
// could not create, tell and abort
wxMessageBox(wxT("Could not create directory"), wxT("Error"), wxOK | wxICON_ERROR, this);
return -1;
}
}
else
{
// we abort because the user did not want to make the directory
wxMessageBox(wxT("Build Project aborted, nothing done."), wxT("Aborted"),
wxOK | wxICON_EXCLAMATION, this);
return -1;
}
}
/** show progress dialog that informs the user with a progress bar */
if(m_progressDlg)
m_progressDlg->Destroy();
m_progressDlg = new CMProgressDialog(this);
m_progressDlg->Show();
// set the wait cursor
m_RunningConfigure = true;
UpdateWindowState();
// always save the current gui values to disk
SaveCacheFromGUI();
// Make sure we are working from the cache on disk
LoadCacheFromDiskToGUI();
// setup the cmake instance
if (generateProjectFiles)
{
if(m_cmake->Generate() != 0)
{
wxMessageBox(err, wxT("Error"), wxOK | wxICON_ERROR, this);
cmSystemTools::Error(err.c_str());
value = -1;
}
else
{
value = 0;
m_cmOptions->SetProjectGenerated(true); // clear cache dirty when generated
}
}
else
{
// set paths
m_cmake->SetHomeDirectory(m_cmProjectPath->GetValue().c_str());
m_cmake->SetStartDirectory(m_cmProjectPath->GetValue().c_str());
m_cmake->SetHomeOutputDirectory(m_cmBuildPath->GetValue().c_str());
m_cmake->SetStartOutputDirectory(m_cmBuildPath->GetValue().c_str());
m_cmake->SetGlobalGenerator(m_cmake->CreateGlobalGenerator(m_cmGeneratorChoice->GetValue().c_str()));
m_cmake->SetCMakeCommand(m_PathToExecutable.c_str());
m_cmake->LoadCache();
if(m_cmake->Configure() != 0)
{
wxMessageBox(err, wxT("Error"), wxOK | wxICON_ERROR, this);
cmSystemTools::Error(err.c_str());
}
// update the GUI with any new values in the caused by the
// generation process
LoadCacheFromDiskToGUI();
}
m_RunningConfigure = false;
if(!value)
cmSystemTools::ResetErrorOccuredFlag();
m_progressDlg->Destroy();
m_progressDlg = 0;
// reset the statusbar progress
wxStatusBar *bar = GetStatusBar();
if(bar)
bar->SetStatusText(wxEmptyString, 1);
UpdateWindowState();
return value;
}
//! Save GUI values to cmCacheManager and then save to disk.
void CMakeSetupFrm::SaveCacheFromGUI()
{
cmCacheManager *cachem = m_cmake->GetCacheManager();
FillCacheManagerFromCacheGUI();
// write the cache to disk
if(!m_cmBuildPath->GetValue().Trim().IsEmpty())
cachem->SaveCache(m_cmBuildPath->GetValue().c_str());
}
void CMakeSetupFrm::FillCacheManagerFromCacheGUI()
{
cmCacheManager *cachem = m_cmake->GetCacheManager();
cmCacheManager::CacheIterator it = cachem->NewIterator();
for(size_t i = 0; i < m_cmOptions->GetCount(); i++)
{
wxPropertyItem* item = m_cmOptions->GetItem(i);
if ( it.Find((const char*)item->GetPropName().c_str()) )
{
// if value is enclosed in single quotes ('foo') then remove them
// they were used to enforce the fact that it had 'invisible'
// trailing stuff
if (item->GetCurValue().Len() >= 2 &&
item->GetCurValue().GetChar(0) == '\'' &&
item->GetCurValue().GetChar(item->GetCurValue().Len() - 1) == '\'')
{
it.SetValue(item->GetCurValue().Mid(1, item->GetCurValue().Len() - 2).c_str());
}
else
it.SetValue(item->GetCurValue().c_str());
}
}
}
/*!
* wxEVT_COMMAND_BUTTON_CLICKED event handler for ID_DO_OK
*/
void CMakeSetupFrm::OnButtonOk( wxCommandEvent& event )
{
DoGenerate();
}
void CMakeSetupFrm::DoGenerate()
{
cmSystemTools::EnableMessages();
cmSystemTools::ResetErrorOccuredFlag();
m_cmOptions->HideControls();
PerformCacheRun();
if(!RunCMake(true))
{
// issue a close when this is done (this is issued by menu "Generate and Exit"
if(m_quitAfterGenerating)
Close();
else if(!wxGetKeyState(WXK_SHIFT))
{
bool close;
m_config->Read(CM_CLOSEAFTERGEN, &close, CM_CLOSEAFTERGEN_DEF);
if(!close)
wxMessageBox(wxT("Building of project files succesful!"), wxT("Success!"), wxOK|wxICON_INFORMATION);
else
Close();
}
}
}
/*!
* wxEVT_COMMAND_BUTTON_CLICKED event handler for ID_DO_CANCEL
*/
void CMakeSetupFrm::OnButtonCancel( wxCommandEvent& event )
{
DoCancelButton();
}
void CMakeSetupFrm::DoCancelButton()
{
if(m_RunningConfigure)
{
int result = wxMessageBox(wxT("You are in the middle of a Configure.\n"
"If you Cancel now the configure information will be lost.\n"
"Are you sure you want to Cancel?"), wxT("Warning"), wxYES_NO|wxICON_WARNING);
if(result == wxYES)
cmSystemTools::SetFatalErrorOccured();
else
if(m_progressDlg)
m_progressDlg->ResetCancel();
}
}
/*!
* wxEVT_COMMAND_BUTTON_CLICKED event handler for ID_DO_DELETE_CACHE
*/
void CMakeSetupFrm::OnButtonDeleteCache( wxCommandEvent& event )
{
DoDeleteCache();
}
void CMakeSetupFrm::DoDeleteCache()
{
bool deletecache = true;
if(m_cmOptions->IsCacheDirty() || (m_cmOptions->GetCount() > 0 && !m_cmOptions->IsGenerated()))
{
int result = ::wxMessageBox(_("You have changed options, are you sure you want to delete all items?\n"),
_("Warning"), wxYES_NO|wxICON_QUESTION);
// when user wants to wait, wait.. else quit
if(result == wxNO)
deletecache = false;
}
if(deletecache)
{
// indicate that we haven't generated a project yet
m_cmOptions->SetProjectGenerated(false);
if(!m_cmBuildPath->GetValue().Trim().IsEmpty() && m_cmake != 0)
m_cmake->GetCacheManager()->DeleteCache(m_cmBuildPath->GetValue().Trim());
LoadCacheFromDiskToGUI();
UpdateWindowState();
}
}
/*!
* Should we show tooltips?
*/
bool CMakeSetupFrm::ShowToolTips()
{
return TRUE;
}
/*!
* Get bitmap resources
*/
wxBitmap CMakeSetupFrm::GetBitmapResource( const wxString& name )
{
// Bitmap retrieval
////@begin CMakeSetupFrm bitmap retrieval
return wxNullBitmap;
////@end CMakeSetupFrm bitmap retrieval
}
/*!
* Get icon resources
*/
wxIcon CMakeSetupFrm::GetIconResource( const wxString& name )
{
// Icon retrieval
////@begin CMakeSetupFrm icon retrieval
if (name == wxT("cmake_icon.xpm"))
{
wxIcon icon(_T("cmake_icon.xpm"), wxBITMAP_TYPE_XPM);
return icon;
}
return wxNullIcon;
////@end CMakeSetupFrm icon retrieval
}
/*!
* wxEVT_COMMAND_SPLITTER_SASH_POS_CHANGING event handler for ID_SPLITTERWINDOW
*/
void CMakeSetupFrm::OnSplitterPosChanging( wxSplitterEvent& event )
{
int width, height;
GetSize(&width, &height);
if((height > 100))
{
if(event.GetSashPosition() < 170)
event.SetSashPosition(170);
else
{
if(event.GetSashPosition() > (height - 180))
event.SetSashPosition(height - 180);
}
}
else
event.Veto();
}
/*!
* wxEVT_COMMAND_BUTTON_CLICKED event handler for ID_CLEAR_LOG
*/
void CMakeSetupFrm::OnClearLogClick( wxCommandEvent& event )
{
// delete the log text
m_cmLog->Clear();
m_cmLog->DiscardEdits();
}
/*!
* wxEVT_COMMAND_TEXT_UPDATED event handler for ID_SOURCE_BUILD_PATH
*/
void CMakeSetupFrm::OnSourceBuildPathUpdated( wxCommandEvent& event )
{
DoReloadCache();
}
void CMakeSetupFrm::DoReloadCache()
{
wxString buildpath = m_cmBuildPath->GetValue();
// The build dir has changed, check if there is a cache, and
// grab the source dir from it
// make sure the call to update grid is not executed
m_noRefresh = true;
m_cmSearchQuery->SetValue(_(""));
m_noRefresh = false;
std::string path = buildpath.c_str();
cmSystemTools::ConvertToUnixSlashes(path);
// adjust the cmake instance
m_cmake->SetHomeOutputDirectory(buildpath.c_str());
m_cmake->SetStartOutputDirectory(buildpath.c_str());
std::string cache_file = path;
cache_file += "/CMakeCache.txt";
// fill in the project path where the source is located, this is
// read from the CMake cache
cmCacheManager *cachem = m_cmake->GetCacheManager();
cmCacheManager::CacheIterator it = cachem->NewIterator();
if (cmSystemTools::FileExists(cache_file.c_str()) && cachem->LoadCache(path.c_str()) &&
it.Find("CMAKE_HOME_DIRECTORY"))
{
path = ConvertToWindowsPath(it.GetValue());
m_cmProjectPath->SetValue(path.c_str());
}
m_cmOptions->RemoveAll();
LoadCacheFromDiskToGUI();
UpdateWindowState();
}
/*!
* wxEVT_COMMAND_TEXT_ENTER event handler for ID_SOURCE_BUILD_PATH
*/
void CMakeSetupFrm::OnSourceBuildPathEnter( wxCommandEvent& event )
{
OnSourceBuildPathUpdated(event);
}
/*!
* wxEVT_MOTION event handler for ID_OPTIONS
*/
void CMakeSetupFrm::OnPropertyMotion( wxMouseEvent& event )
{
ShowPropertyDescription(m_cmOptions->YToRow(event.GetY()));
event.Skip();
}
/*!
* wxEVT_GRID_SELECT_CELL event handler for ID_OPTIONS
*/
void CMakeSetupFrm::OnGridSelectCell( wxGridEvent& event )
{
// show description
ShowPropertyDescription(event.GetRow());
// enable or disable the browse button
m_cmBrowseCell->Enable(m_cmOptions->IsSelectedItemBrowsable(event.GetRow()));
event.Skip();
}
void CMakeSetupFrm::ShowPropertyDescription(int row)
{
if(row == wxNOT_FOUND || row < 0)
m_cmDescription->SetValue(wxEmptyString);
else
{
wxPropertyItem *pItem = m_cmOptions->GetPropertyItemFromRow(row);
if(pItem)
m_cmDescription->SetValue(pItem->GetHelpString());
else
m_cmDescription->SetValue(wxEmptyString);
}
}
/*!
* wxEVT_GRID_CELL_CHANGE event handler for ID_OPTIONS
*/
void CMakeSetupFrm::OnCellChange( wxGridEvent& event )
{
// update the button state when the cache is invalidated
UpdateWindowState();
}
void CMakeSetupFrm::OnRecentFileMenu( wxCommandEvent &event )
{
if(GetMenuBar())
{
// get file menu
wxMenu *mnu = GetMenuBar()->GetMenu(0);
wxASSERT(mnu != 0);
wxMenuItem *item = mnu->FindItem(event.GetId());
if(item)
m_cmBuildPath->SetValue(item->GetLabel());
}
}
/*!
* wxEVT_COMMAND_COMBOBOX_SELECTED event handler for ID_COMBOBOX
*/
void CMakeSetupFrm::OnSearchquerySelected( wxCommandEvent& event )
{
m_cmOptions->SetQuery(m_cmSearchQuery->GetValue());
}
void CMakeSetupFrm::OnAddQuery ( wxCommandEvent &event )
{
// add current text if not yet present
if(m_cmSearchQuery->FindString(m_cmSearchQuery->GetValue()) == wxNOT_FOUND)
{
m_cmSearchQuery->Append(m_cmSearchQuery->GetValue());
// if too many items are present, prune
while(m_cmSearchQuery->GetCount() > CM_MAX_SEARCH_QUERIES)
m_cmSearchQuery->Delete(0);
}
}
/*!
* wxEVT_COMMAND_TEXT_UPDATED event handler for ID_SEARCHQUERY
*/
void CMakeSetupFrm::OnSearchqueryUpdated( wxCommandEvent& event )
{
// only refresh when this event was caused by user
if(!m_noRefresh)
m_cmOptions->SetQuery(m_cmSearchQuery->GetValue());
}
/*!
* wxEVT_COMMAND_BUTTON_CLICKED event handler for ID_BROWSE_GRID
*/
void CMakeSetupFrm::OnBrowseGridClick( wxCommandEvent& event )
{
m_cmOptions->BrowseSelectedItem();
}
/*!
* wxEVT_COMMAND_MENU_SELECTED event handler for ID_MENU_RELOAD_CACHE
*/
void CMakeSetupFrm::OnMenuReloadCacheClick( wxCommandEvent& event )
{
bool reload = true;
if(m_cmOptions->IsCacheDirty() || (m_cmOptions->GetCount() > 0 && !m_cmOptions->IsGenerated()))
{
int result = ::wxMessageBox(_("You have changed options, are you sure you want to reload?\n"),
_("Warning"), wxYES_NO|wxICON_QUESTION);
// when user wants to wait, wait.. else quit
if(result == wxNO)
reload = false;
}
if(reload)
DoReloadCache();
}
/*!
* wxEVT_COMMAND_MENU_SELECTED event handler for ID_MENU_DELETE_CACHE
*/
void CMakeSetupFrm::OnMenuDeleteCacheClick( wxCommandEvent& event )
{
DoDeleteCache();
}
/*!
* wxEVT_COMMAND_MENU_SELECTED event handler for ID_MENU_QUIT
*/
void CMakeSetupFrm::OnMenuQuitClick( wxCommandEvent& event )
{
// the close event will veto if the user
// did not want to quit due to unsaved changes
Close();
}
/*!
* wxEVT_CLOSE_WINDOW event handler for ID_FRAME
*/
void CMakeSetupFrm::OnCloseWindow( wxCloseEvent& event )
{
// ask quit if:
// - The cache is dirty
// - Or the cache is OK and has some items, and no project was generated recently (configure -> generate)
if(m_cmOptions->IsCacheDirty() || (m_cmOptions->GetCount() > 0 && !m_cmOptions->IsGenerated()))
{
int result = ::wxMessageBox(_("You have changed options, but not yet generated the projects\n"
"are you sure you want to quit?"), _("Warning"), wxYES_NO|wxICON_QUESTION);
// when user wants to wait, wait.. else quit
if(result == wxNO)
event.Veto();
else
event.Skip();
}
else
event.Skip();
}
/*!
* wxEVT_COMMAND_MENU_SELECTED event handler for ID_ABOUTDLG
*/
void CMakeSetupFrm::OnAboutClick( wxCommandEvent& event )
{
CMAboutDlg *dlg = new CMAboutDlg(this);
wxArrayString generators;
std::vector<std::string> names;
m_cmake->GetRegisteredGenerators(names);
for(std::vector<std::string>::iterator i = names.begin(); i != names.end(); ++i)
generators.Add(i->c_str());
wxString cmversion, cmsversion;
cmversion.Printf("v%i.%i %s", cmake::GetMajorVersion(), cmake::GetMinorVersion(), cmake::GetReleaseVersion());
cmsversion.Printf("v%i.%i%s", CMAKEGUI_MAJORVER, CMAKEGUI_MINORVER, CMAKEGUI_ADDVER);
dlg->SetAboutText(cmversion, cmsversion, generators);
dlg->ShowModal();
dlg->Destroy();
}
/*!
* wxEVT_COMMAND_MENU_SELECTED event handler for ID_CMAKE_OPTIONS
*/
void CMakeSetupFrm::OnOptionsClick( wxCommandEvent& event )
{
CMOptionsDlg *dlg = new CMOptionsDlg(this);
dlg->SetConfig(m_config);
if(dlg->ShowModal() == wxID_OK)
{
// store volatile settings
dlg->GetConfig(m_config);
// apply non volatile setting such as clear search query, recent menu, etc.
SyncFormOptions(dlg);
}
dlg->Destroy();
}
void CMakeSetupFrm::SyncFormOptions(CMOptionsDlg *dlg)
{
// TODO: Clear search query etc.
}
/*!
* wxEVT_COMMAND_SPLITTER_DOUBLECLICKED event handler for ID_SPLITTERWINDOW
*/
void CMakeSetupFrm::OnSplitterwindowSashDClick( wxSplitterEvent& event )
{
event.Veto();
}
/*!
* wxEVT_COMMAND_MENU_SELECTED event handler for ID_MENU_CONFIGURE
*/
void CMakeSetupFrm::OnMenuConfigureClick( wxCommandEvent& event )
{
DoConfigure();
}
/*!
* wxEVT_COMMAND_MENU_SELECTED event handler for ID_MENU_EXITGENERATE
*/
void CMakeSetupFrm::OnMenuGenerateClick( wxCommandEvent& event )
{
// set flag so that a close command is issued
// after generating the cmake cache to projects
m_quitAfterGenerating = true;
DoGenerate();
m_quitAfterGenerating = false;
}
/*!
* wxEVT_COMMAND_MENU_SELECTED event handler for ID_MENU_TOGGLE_ADVANCED
*/
void CMakeSetupFrm::OnMenuToggleAdvancedClick( wxCommandEvent& event )
{
// toggle the check box
m_cmShowAdvanced->SetValue(!m_cmShowAdvanced->GetValue());
OnShowAdvancedValues(event);
}
Reference in New Issue View Git Blame Copy Permalink