CMakeLua/Source/WXDialog/CMakeSetupFrame.cpp

   1 /*=========================================================================
   2
   3   Program:   WXDialog - wxWidgets X-platform GUI Front-End for CMake
   4   Module:    $RCSfile: CMakeSetupFrame.cpp,v $
   5   Language:  C++
   6 <<<<<<< CMakeSetupFrame.cpp
   7   Date:      $Date: 2007/11/05 19:47:20 $
   8   Version:   $Revision: 1.3 $
   9 =======
  10   Date:      $Date: 2009-03-05 20:17:07 $
  11   Version:   $Revision: 1.4 $
  12 >>>>>>> 1.4
  13
  14   Author:    Jorgen Bodde
  15
  16   Copyright (c) 2002 Kitware, Inc., Insight Consortium.  All rights reserved.
  17   See Copyright.txt or http://www.cmake.org/HTML/Copyright.html for details.
  18
  19      This software is distributed WITHOUT ANY WARRANTY; without even
  20      the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
  21      PURPOSE.  See the above copyright notices for more information.
  22
  23 =========================================================================*/
  24
  25 #if defined(__GNUG__) && !defined(__APPLE__)
  26 #pragma implementation "CMakeSetupFrame.h"
  27 #endif
  28
  29 // For compilers that support precompilation, includes "wx/wx.h".
  30 #include "wx/wxprec.h"
  31
  32 #ifdef __BORLANDC__
  33 #pragma hdrstop
  34 #endif
  35
  36 #ifndef WX_PRECOMP
  37 #include "wx/wx.h"
  38 #endif
  39
  40 ////@begin includes
  41 ////@end includes
  42
  43 #include <wx/dirdlg.h>
  44 #include <wx/msgdlg.h>
  45 #include <wx/filename.h>
  46
  47 #include "CMakeSetupFrame.h"
  48 #include "PropertyList.h"
  49 #include "app_resources.h"
  50 #include "CMakeIcon.xpm"
  51 #include "aboutdlg.h"
  52
  53 // cmake includes
  54 #include "../cmVersion.h"
  55 #include "../cmListFileCache.h"
  56 #include "../cmCacheManager.h"
  57 #include "../cmGlobalGenerator.h"
  58 #include "../cmDynamicLoader.h"
  59
  60 ////@begin XPM images
  61 ////@end XPM images
  62
  63 /*!
  64  * CMakeSetupFrm type definition
  65  */
  66
  67 IMPLEMENT_CLASS( CMakeSetupFrm, wxFrame )
  68
  69 /*!
  70  * CMakeSetupFrm event table definition
  71  */
  72
  73 BEGIN_EVENT_TABLE( CMakeSetupFrm, wxFrame )
  74
  75 ////@begin CMakeSetupFrm event table entries
  76     EVT_CLOSE( CMakeSetupFrm::OnCloseWindow )
  77
  78     EVT_SPLITTER_SASH_POS_CHANGING( ID_SPLITTERWINDOW, CMakeSetupFrm::OnSplitterPosChanging )
  79     EVT_SPLITTER_DCLICK( ID_SPLITTERWINDOW, CMakeSetupFrm::OnSplitterwindowSashDClick )
  80
  81     EVT_BUTTON( ID_BROWSE_PROJECT, CMakeSetupFrm::OnButtonBrowseProject )
  82
  83     EVT_TEXT( ID_SOURCE_BUILD_PATH, CMakeSetupFrm::OnSourceBuildPathUpdated )
  84     EVT_TEXT_ENTER( ID_SOURCE_BUILD_PATH, CMakeSetupFrm::OnSourceBuildPathEnter )
  85
  86     EVT_BUTTON( ID_BROWSE_BUILD, CMakeSetupFrm::OnButtonBrowseBuild )
  87
  88     EVT_COMBOBOX( ID_SEARCHQUERY, CMakeSetupFrm::OnSearchquerySelected )
  89     EVT_TEXT( ID_SEARCHQUERY, CMakeSetupFrm::OnSearchqueryUpdated )
  90
  91     EVT_CHECKBOX( ID_SHOW_ADVANCED, CMakeSetupFrm::OnShowAdvancedValues )
  92
  93     EVT_GRID_CELL_CHANGE( CMakeSetupFrm::OnCellChange )
  94     EVT_GRID_SELECT_CELL( CMakeSetupFrm::OnGridSelectCell )
  95     EVT_MOTION( CMakeSetupFrm::OnPropertyMotion )
  96
  97     EVT_BUTTON( ID_DO_CONFIGURE, CMakeSetupFrm::OnButtonConfigure )
  98
  99     EVT_BUTTON( ID_DO_OK, CMakeSetupFrm::OnButtonOk )
 100
 101     EVT_BUTTON( ID_DO_CANCEL, CMakeSetupFrm::OnButtonCancel )
 102
 103     EVT_BUTTON( ID_DO_DELETE_CACHE, CMakeSetupFrm::OnButtonDeleteCache )
 104
 105     EVT_BUTTON( ID_CLEAR_LOG, CMakeSetupFrm::OnClearLogClick )
 106
 107     EVT_BUTTON( ID_BROWSE_GRID, CMakeSetupFrm::OnBrowseGridClick )
 108
 109     EVT_MENU( ID_MENU_RELOAD_CACHE, CMakeSetupFrm::OnMenuReloadCacheClick )
 110
 111     EVT_MENU( ID_MENU_DELETE_CACHE, CMakeSetupFrm::OnMenuDeleteCacheClick )
 112
 113     EVT_MENU( ID_MENU_QUIT, CMakeSetupFrm::OnMenuQuitClick )
 114
 115     EVT_MENU( ID_MENU_CONFIGURE, CMakeSetupFrm::OnMenuConfigureClick )
 116
 117     EVT_MENU( ID_MENU_EXITGENERATE, CMakeSetupFrm::OnMenuGenerateClick )
 118
 119     EVT_MENU( ID_MENU_TOGGLE_ADVANCED, CMakeSetupFrm::OnMenuToggleAdvancedClick )
 120
 121     EVT_MENU( ID_CMAKE_OPTIONS, CMakeSetupFrm::OnOptionsClick )
 122
 123     EVT_MENU( ID_ABOUTDLG, CMakeSetupFrm::OnAboutClick )
 124
 125 ////@end CMakeSetupFrm event table entries
 126
 127     EVT_MENU_RANGE(CM_RECENT_BUILD_ITEM, CM_RECENT_BUILD_ITEM + CM_MAX_RECENT_PATHS, CMakeSetupFrm::OnRecentFileMenu)
 128
 129     EVT_TEXT_ENTER(ID_SEARCHQUERY, CMakeSetupFrm::OnAddQuery )
 130
 131 END_EVENT_TABLE()
 132
 133 /** Callback function for CMake generator, to tell user how
 134     far the generation actually is */
 135 void updateProgress(const char *msg, float prog, void *cd)
 136 {
 137     // TODO: Make some kind of progress counter
 138
 139     CMakeSetupFrm *fm = (CMakeSetupFrm *)cd;
 140
 141     if(fm)
 142     {
 143         if(prog < 0)
 144             fm->LogMessage(0, msg);
 145         else
 146         {
 147             fm->UpdateProgress(prog);
 148             fm->IssueUpdate();
 149         }
 150     }
 151 }
 152
 153 /** Callback function for CMake generator, to tell user about stuff. This should be
 154     logged in the m_log window */
 155 void MFCMessageCallback(const char* m, const char* title, bool& nomore, void *clientdata)
 156 {
 157     CMakeSetupFrm *fm = (CMakeSetupFrm *)clientdata;
 158
 159     if(fm)
 160     {
 161         wxString what = m, msg;
 162         if(what.StartsWith("CMake Error: "))
 163             fm->LogMessage(-1, m);
 164         else
 165             fm->LogMessage(1, m);
 166     }
 167 }
 168
 169 // Convert to Win32 path (slashes). This calls the system tools one and then
 170 // removes the spaces. It is not in system tools because we don't want any
 171 // generators accidentally use it
 172 std::string ConvertToWindowsPath(const char* path)
 173 {
 174   // Convert to output path.
 175   // Remove the "" around it (if any) since it's an output path for
 176   // the shell. If another shell-oriented feature is not designed
 177   // for a GUI use, then we are in trouble.
 178   // save the value of the force to unix path option
 179   bool saveForce = cmSystemTools::GetForceUnixPaths();
 180   // make sure we get windows paths no matter what for the GUI
 181   cmSystemTools::SetForceUnixPaths(false);
 182   std::string s = cmSystemTools::ConvertToOutputPath(path);
 183   // now restore the force unix path to its previous value
 184   cmSystemTools::SetForceUnixPaths(saveForce);
 185   if (s.size())
 186     {
 187     std::string::iterator i = s.begin();
 188     if (*i == '\"')
 189       {
 190       s.erase(i, i + 1);
 191       }
 192     i = s.begin() + s.length() - 1;
 193     if (*i == '\"')
 194       {
 195       s.erase(i, i + 1);
 196       }
 197     }
 198   return s;
 199 }
 200
 201
 202 bool DnDFile::OnDropFiles(wxCoord, wxCoord, const wxArrayString& filenames)
 203 {
 204     size_t nFiles = filenames.GetCount();
 205
 206     // only one item allowed
 207     if(nFiles > 1)
 208         return false;
 209
 210     if(nFiles == 1)
 211     {
 212         // only one dir allowed
 213         if(!wxDirExists(filenames[0]))
 214             return false;
 215
 216         // strip the seperator
 217         wxFileName name;
 218         name.AssignDir(filenames[0]);
 219
 220         // issue a 'drop' by changing text ctrl
 221         m_pOwner->SetValue(name.GetFullPath());
 222
 223         return true;
 224     }
 225
 226     return false;
 227 }
 228
 229 /*!
 230  * CMakeSetupFrm constructors
 231  */
 232
 233 CMakeSetupFrm::CMakeSetupFrm( )
 234     : m_cmake(0)
 235 {
 236 }
 237
 238 CMakeSetupFrm::CMakeSetupFrm( wxWindow* parent, wxWindowID id, const wxString& caption, const wxPoint& pos, const wxSize& size, long style )
 239     : m_cmake(0)
 240 {
 241     Create( parent, id, caption, pos, size, style );
 242 }
 243
 244 /*!
 245  * CMakeSetupFrm creator
 246  */
 247
 248 bool CMakeSetupFrm::Create( wxWindow* parent, wxWindowID id, const wxString& caption, const wxPoint& pos, const wxSize& size, long style )
 249 {
 250 ////@begin CMakeSetupFrm member initialisation
 251     m_splitter = NULL;
 252     m_cmProjectPath = NULL;
 253     m_BrowseProjectPathButton = NULL;
 254     m_cmBuildPath = NULL;
 255     m_BrowseSourcePathButton = NULL;
 256     m_cmGeneratorChoice = NULL;
 257     m_cmSearchQuery = NULL;
 258     m_cmShowAdvanced = NULL;
 259     m_cmOptions = NULL;
 260     m_cmLog = NULL;
 261     m_cmDescription = NULL;
 262     m_ConfigureButton = NULL;
 263     m_OkButton = NULL;
 264     m_CancelButton = NULL;
 265     m_DeleteCacheButton = NULL;
 266     m_ClearLogButton = NULL;
 267     m_cmBrowseCell = NULL;
 268 ////@end CMakeSetupFrm member initialisation
 269
 270     wxFrame::Create( parent, id, caption, pos, size, style );
 271
 272     // make sure the developer does not assign more then 100
 273     // would be rediculous but also overlap other id's
 274     wxASSERT(CM_MAX_RECENT_PATHS < 100);
 275
 276     m_ExitTimer = 0;
 277
 278     m_progressDlg = 0;
 279     m_noRefresh = false;
 280     m_quitAfterGenerating = false;
 281
 282     m_config = new wxConfig("CMakeSetup");
 283
 284     wxIcon icon(CMakeIcon_xpm);
 285     SetIcon(icon);
 286
 287     CreateControls();
 288
 289     //SetIcon(GetIconResource(wxT("cmake_icon.xpm")));
 290     //SetIcon(wxIcon("NGDialog.ico", wxBITMAP_TYPE_ICO_RESOURCE));
 291     Centre();
 292
 293     // is it needed to hide console?
 294     m_RunningConfigure = false;
 295     cmSystemTools::SetRunCommandHideConsole(true);
 296     cmSystemTools::SetErrorCallback(MFCMessageCallback, (void *)this);
 297
 298     // create our cmake instance
 299     m_cmake = new cmake;
 300     m_cmake->SetProgressCallback(updateProgress, (void *)this);
 301
 302     return TRUE;
 303 }
 304
 305 CMakeSetupFrm::~CMakeSetupFrm()
 306 {
 307     wxString str;
 308
 309     // write configs back to disk
 310     m_config->Write(CM_LASTPROJECT_PATH, m_cmProjectPath->GetValue());
 311     m_config->Write(CM_LASTBUILD_PATH, m_cmBuildPath->GetValue());
 312
 313     // clear the config first
 314     for(size_t i = 0 ; i < CM_MAX_RECENT_PATHS; i++)
 315     {
 316         str.Printf("%s%i", _(CM_RECENT_BUILD_PATH), i);
 317         m_config->Write(str, _(""));
 318     }
 319
 320     // write the last CM_MAX_RECENT_PATHS items back to config
 321     int i = (m_recentPaths.Count() >= CM_MAX_RECENT_PATHS ? CM_MAX_RECENT_PATHS : m_recentPaths.Count());
 322     while(i > 0)
 323     {
 324         str.Printf("%s%i", _(CM_RECENT_BUILD_PATH), i);
 325         m_config->Write(str, m_recentPaths[i - 1]);
 326         i--;
 327     }
 328
 329     // write recent query list to config
 330     for(int j = 0; j < m_cmSearchQuery->GetCount(); j++)
 331     {
 332         // allow max to be written
 333         if(j < CM_MAX_SEARCH_QUERIES)
 334         {
 335             str.Printf("%s%i", _(CM_SEARCH_QUERY), j);
 336             m_config->Write(str, m_cmSearchQuery->GetString(j));
 337         }
 338         else
 339             break;
 340     }
 341
 342     // set window pos + size in settings
 343     if(!IsIconized() && !IsMaximized())
 344     {
 345         int xsize, ysize;
 346         GetSize(&xsize, &ysize);
 347         if(xsize > 0 && ysize > 0)
 348         {
 349             m_config->Write(CM_XSIZE, (long)xsize);
 350             m_config->Write(CM_YSIZE, (long)ysize);
 351         }
 352
 353         if(m_splitter->GetSashPosition() > 0)
 354             m_config->Write(CM_SPLITTERPOS, (long)m_splitter->GetSashPosition());
 355
 356         GetPosition(&xsize, &ysize);
 357         if(xsize != 0 && ysize != 0)
 358         {
 359             m_config->Write(CM_XPOS, (long)xsize);
 360             m_config->Write(CM_YPOS, (long)ysize);
 361         }
 362     }
 363
 364     // write changes (will be done before deletion)
 365     delete m_config;
 366
 367     // delete timer
 368     if(m_ExitTimer)
 369         delete m_ExitTimer;
 370
 371     // delete our cmake instance again
 372     if(m_cmake)
 373         delete m_cmake;
 374 }
 375
 376 void CMakeSetupFrm::UpdateWindowState()
 377 {
 378     bool dogenerate = !m_RunningConfigure && !m_cmOptions->IsCacheDirty() &&
 379                        (m_cmOptions->GetCount() != 0);
 380
 381     // when configure is running, disable a lot of stuff
 382     m_cmProjectPath->Enable(!m_RunningConfigure);
 383     m_BrowseProjectPathButton->Enable(!m_RunningConfigure);
 384     m_cmBuildPath->Enable(!m_RunningConfigure);
 385     m_BrowseSourcePathButton->Enable(!m_RunningConfigure);
 386     m_cmGeneratorChoice->Enable(!m_RunningConfigure);
 387     m_cmShowAdvanced->Enable(!m_RunningConfigure);
 388     m_cmOptions->Enable(!m_RunningConfigure);
 389     m_ConfigureButton->Enable(!m_RunningConfigure);
 390     m_OkButton->Enable(dogenerate);
 391     m_CancelButton->Enable(m_RunningConfigure);
 392     m_DeleteCacheButton->Enable(!m_RunningConfigure);
 393     m_ClearLogButton->Enable(!m_RunningConfigure);
 394     if(m_RunningConfigure)
 395         m_cmBrowseCell->Enable(false);
 396
 397     // when cache loaded (items available show other control)
 398     m_cmGeneratorChoice->Enable(m_cmOptions->GetCount() == 0 && !m_RunningConfigure);
 399     m_cmSearchQuery->Enable(!m_RunningConfigure);
 400     m_cmBrowseCell->Enable(!m_RunningConfigure && m_cmOptions->IsSelectedItemBrowsable());
 401
 402     // disable the menus when configuring
 403     if(GetMenuBar())
 404     {
 405         // disable configure button when there is nothing, and generate and exit
 406         // only when it is allowed to generate
 407         GetMenuBar()->Enable(ID_MENU_EXITGENERATE, dogenerate);
 408         GetMenuBar()->Enable(ID_MENU_CONFIGURE, !m_RunningConfigure);
 409
 410         for(size_t i = 0; i < GetMenuBar()->GetMenuCount(); i++)
 411             GetMenuBar()->EnableTop(i, !m_RunningConfigure);
 412     }
 413 }
 414
 415 void CMakeSetupFrm::LogMessage(int logkind, const char *msg)
 416 {
 417     // put CR first but prevent a CR at the end
 418 #ifndef __LINUX__
 419     if(m_cmLog->IsModified())
 420         (*m_cmLog) << wxT("\n");
 421 #else
 422     // Linux requires a different approach
 423     if(!m_cmLog->GetValue().IsEmpty())
 424         (*m_cmLog) << wxT("\n");
 425 #endif
 426
 427     // log error, warning, or message
 428     wxTextAttr defattr = m_cmLog->GetDefaultStyle();
 429
 430     switch(logkind)
 431     {
 432     // user message
 433     case 1:
 434         {
 435             wxTextAttr colattr(*wxBLUE);
 436             m_cmLog->SetDefaultStyle(colattr);
 437             (*m_cmLog) << msg;
 438             m_cmLog->SetDefaultStyle(defattr);
 439         }
 440         break;
 441
 442     // progress
 443     case 0:
 444         (*m_cmLog) << msg;
 445         break;
 446
 447     // error
 448     case -1:
 449         {
 450             wxTextAttr colattr(*wxRED);
 451             m_cmLog->SetDefaultStyle(colattr);
 452             (*m_cmLog) << msg;
 453             m_cmLog->SetDefaultStyle(defattr);
 454         }
 455         break;
 456     }
 457
 458     IssueUpdate();
 459 }
 460
 461 void CMakeSetupFrm::IssueUpdate()
 462 {
 463     //::wxSafeYield(m_CancelButton, true);
 464     ::wxYield();
 465
 466     // when we pressed cancel on the progress dialog
 467     // stop all activities
 468     if(m_progressDlg)
 469     {
 470         if(m_progressDlg->CancelPressed() && !m_progressDlg->IsCancelling())
 471         {
 472             m_progressDlg->CancelAcknowledged();
 473
 474             // send a button event to cancel the progress
 475             wxCommandEvent event( wxEVT_COMMAND_BUTTON_CLICKED, ID_DO_CANCEL);
 476             wxPostEvent(this, event);
 477         }
 478     }
 479 }
 480
 481 /*!
 482  * Control creation for CMakeSetupFrm
 483  */
 484
 485 void CMakeSetupFrm::CreateControls()
 486 {
 487 ////@begin CMakeSetupFrm content construction
 488     CMakeSetupFrm* itemFrame1 = this;
 489
 490     wxMenuBar* menuBar = new wxMenuBar;
 491     wxMenu* itemMenu37 = new wxMenu;
 492     itemMenu37->Append(ID_MENU_RELOAD_CACHE, _("&Reload Cache\tCtrl+R"), _("Reload the cache from disk"), wxITEM_NORMAL);
 493     itemMenu37->Append(ID_MENU_DELETE_CACHE, _("&Delete Cache\tCtrl+D"), _("Delete the cache on disk of the current path"), wxITEM_NORMAL);
 494     itemMenu37->AppendSeparator();
 495     itemMenu37->Append(ID_MENU_QUIT, _("E&xit\tAlt+F4"), _("Quit CMake Setup"), wxITEM_NORMAL);
 496     menuBar->Append(itemMenu37, _("&File"));
 497     wxMenu* itemMenu42 = new wxMenu;
 498     itemMenu42->Append(ID_MENU_CONFIGURE, _("&Configure\tCtrl+N"), _T(""), wxITEM_NORMAL);
 499     itemMenu42->Append(ID_MENU_EXITGENERATE, _("&Generate and Exit\tCtrl+G"), _T(""), wxITEM_NORMAL);
 500     itemMenu42->Append(ID_MENU_TOGGLE_ADVANCED, _("Toggle &Advanced\tCtrl+A"), _T(""), wxITEM_NORMAL);
 501     itemMenu42->AppendSeparator();
 502     itemMenu42->Append(ID_CMAKE_OPTIONS, _("&Options\tCtrl+O"), _T(""), wxITEM_NORMAL);
 503     menuBar->Append(itemMenu42, _("&Tools"));
 504     wxMenu* itemMenu48 = new wxMenu;
 505     itemMenu48->Append(ID_ABOUTDLG, _("&About ..."), _("Shows the about dialog ..."), wxITEM_NORMAL);
 506     menuBar->Append(itemMenu48, _("&Help"));
 507     itemFrame1->SetMenuBar(menuBar);
 508
 509     m_splitter = new wxSplitterWindow( itemFrame1, ID_SPLITTERWINDOW, wxDefaultPosition, wxSize(100, 100), wxSP_3DBORDER|wxSP_3DSASH|wxNO_BORDER );
 510
 511     wxPanel* itemPanel3 = new wxPanel( m_splitter, ID_MAINPANEL, wxDefaultPosition, wxSize(600, 400), wxNO_BORDER|wxTAB_TRAVERSAL );
 512     itemPanel3->SetExtraStyle(itemPanel3->GetExtraStyle()|wxWS_EX_VALIDATE_RECURSIVELY);
 513     wxBoxSizer* itemBoxSizer4 = new wxBoxSizer(wxVERTICAL);
 514     itemPanel3->SetSizer(itemBoxSizer4);
 515
 516     wxBoxSizer* itemBoxSizer5 = new wxBoxSizer(wxHORIZONTAL);
 517     itemBoxSizer4->Add(itemBoxSizer5, 0, wxGROW|wxTOP|wxBOTTOM, 5);
 518     wxFlexGridSizer* itemFlexGridSizer6 = new wxFlexGridSizer(2, 3, 0, 0);
 519     itemFlexGridSizer6->AddGrowableRow(1);
 520     itemFlexGridSizer6->AddGrowableCol(1);
 521     itemBoxSizer5->Add(itemFlexGridSizer6, 1, wxALIGN_TOP|wxLEFT, 5);
 522     wxStaticText* itemStaticText7 = new wxStaticText( itemPanel3, wxID_STATIC, _("CMake project path"), wxDefaultPosition, wxDefaultSize, 0 );
 523     itemFlexGridSizer6->Add(itemStaticText7, 0, wxALIGN_LEFT|wxALIGN_CENTER_VERTICAL|wxLEFT|wxRIGHT|wxADJUST_MINSIZE, 5);
 524
 525     m_cmProjectPath = new wxTextCtrl( itemPanel3, ID_PROJECT_PATH, _T(""), wxDefaultPosition, wxSize(50, -1), 0 );
 526     itemFlexGridSizer6->Add(m_cmProjectPath, 1, wxGROW|wxALIGN_CENTER_VERTICAL|wxTOP|wxBOTTOM, 5);
 527
 528     m_BrowseProjectPathButton = new wxButton( itemPanel3, ID_BROWSE_PROJECT, _("Browse"), wxDefaultPosition, wxSize(55, -1), 0 );
 529     itemFlexGridSizer6->Add(m_BrowseProjectPathButton, 0, wxALIGN_CENTER_HORIZONTAL|wxALIGN_CENTER_VERTICAL|wxALL, 5);
 530
 531     wxStaticText* itemStaticText10 = new wxStaticText( itemPanel3, wxID_STATIC, _("Project build path"), wxDefaultPosition, wxDefaultSize, 0 );
 532     itemFlexGridSizer6->Add(itemStaticText10, 0, wxALIGN_LEFT|wxALIGN_CENTER_VERTICAL|wxLEFT|wxRIGHT|wxADJUST_MINSIZE, 5);
 533
 534     m_cmBuildPath = new wxTextCtrl( itemPanel3, ID_SOURCE_BUILD_PATH, _T(""), wxDefaultPosition, wxSize(50, -1), 0 );
 535     itemFlexGridSizer6->Add(m_cmBuildPath, 1, wxGROW|wxALIGN_TOP|wxTOP|wxBOTTOM, 5);
 536
 537     m_BrowseSourcePathButton = new wxButton( itemPanel3, ID_BROWSE_BUILD, _("Browse"), wxDefaultPosition, wxSize(55, -1), 0 );
 538     itemFlexGridSizer6->Add(m_BrowseSourcePathButton, 0, wxALIGN_CENTER_HORIZONTAL|wxALIGN_CENTER_VERTICAL|wxALL, 5);
 539
 540     wxBoxSizer* itemBoxSizer13 = new wxBoxSizer(wxVERTICAL);
 541     itemBoxSizer5->Add(itemBoxSizer13, 0, wxGROW|wxLEFT|wxRIGHT, 5);
 542     wxFlexGridSizer* itemFlexGridSizer14 = new wxFlexGridSizer(2, 2, 0, 0);
 543     itemBoxSizer13->Add(itemFlexGridSizer14, 0, wxALIGN_CENTER_HORIZONTAL|wxLEFT|wxRIGHT, 5);
 544     wxStaticText* itemStaticText15 = new wxStaticText( itemPanel3, wxID_STATIC, _("Generate"), wxDefaultPosition, wxDefaultSize, 0 );
 545     itemFlexGridSizer14->Add(itemStaticText15, 0, wxALIGN_LEFT|wxALIGN_CENTER_VERTICAL|wxRIGHT|wxADJUST_MINSIZE, 5);
 546
 547     wxString* m_cmGeneratorChoiceStrings = NULL;
 548     m_cmGeneratorChoice = new wxComboBox( itemPanel3, ID_CHOOSE_GENERATOR, _T(""), wxDefaultPosition, wxSize(170, -1), 0, m_cmGeneratorChoiceStrings, wxCB_READONLY );
 549     itemFlexGridSizer14->Add(m_cmGeneratorChoice, 1, wxALIGN_CENTER_HORIZONTAL|wxGROW|wxTOP|wxBOTTOM, 5);
 550
 551     wxStaticText* itemStaticText17 = new wxStaticText( itemPanel3, wxID_STATIC, _("Search"), wxDefaultPosition, wxDefaultSize, 0 );
 552     itemFlexGridSizer14->Add(itemStaticText17, 0, wxALIGN_LEFT|wxALIGN_CENTER_VERTICAL|wxRIGHT|wxADJUST_MINSIZE, 5);
 553
 554     wxString* m_cmSearchQueryStrings = NULL;
 555     m_cmSearchQuery = new wxComboBox( itemPanel3, ID_SEARCHQUERY, _T(""), wxDefaultPosition, wxSize(170, -1), 0, m_cmSearchQueryStrings, wxWANTS_CHARS );
 556     itemFlexGridSizer14->Add(m_cmSearchQuery, 1, wxALIGN_CENTER_HORIZONTAL|wxGROW|wxTOP|wxBOTTOM, 5);
 557
 558     m_cmShowAdvanced = new wxCheckBox( itemPanel3, ID_SHOW_ADVANCED, _("Show advanced values"), wxDefaultPosition, wxDefaultSize, wxCHK_2STATE );
 559     m_cmShowAdvanced->SetValue(FALSE);
 560     itemBoxSizer13->Add(m_cmShowAdvanced, 0, wxALIGN_RIGHT|wxLEFT|wxRIGHT, 5);
 561
 562     m_cmOptions = new wxPropertyList( itemPanel3, ID_OPTIONS, wxDefaultPosition, wxSize(200, 150), wxSTATIC_BORDER|wxWANTS_CHARS|wxVSCROLL );
 563     m_cmOptions->SetDefaultColSize(250);
 564     m_cmOptions->SetDefaultRowSize(25);
 565     m_cmOptions->SetColLabelSize(20);
 566     m_cmOptions->SetRowLabelSize(0);
 567     m_cmOptions->CreateGrid(10, 2, wxGrid::wxGridSelectRows);
 568     itemBoxSizer4->Add(m_cmOptions, 1, wxGROW|wxALL, 5);
 569
 570     wxPanel* itemPanel21 = new wxPanel( m_splitter, ID_LOGPANEL, wxDefaultPosition, wxSize(-1, 100), wxNO_BORDER|wxTAB_TRAVERSAL );
 571     wxBoxSizer* itemBoxSizer22 = new wxBoxSizer(wxVERTICAL);
 572     itemPanel21->SetSizer(itemBoxSizer22);
 573
 574     wxBoxSizer* itemBoxSizer23 = new wxBoxSizer(wxHORIZONTAL);
 575     itemBoxSizer22->Add(itemBoxSizer23, 1, wxGROW|wxLEFT|wxRIGHT|wxTOP, 5);
 576     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 );
 577     itemBoxSizer23->Add(m_cmLog, 1, wxGROW|wxRIGHT, 5);
 578
 579     m_cmDescription = new wxTextCtrl( itemPanel21, ID_DESCRIPTION, _T(""), wxDefaultPosition, wxSize(200, -1), wxTE_MULTILINE|wxTE_READONLY|wxTE_RICH2|wxSTATIC_BORDER );
 580     itemBoxSizer23->Add(m_cmDescription, 0, wxGROW|wxLEFT, 5);
 581
 582     wxBoxSizer* itemBoxSizer26 = new wxBoxSizer(wxHORIZONTAL);
 583     itemBoxSizer22->Add(itemBoxSizer26, 0, wxALIGN_CENTER_HORIZONTAL|wxALL, 5);
 584     m_ConfigureButton = new wxButton( itemPanel21, ID_DO_CONFIGURE, _("Co&nfigure"), wxDefaultPosition, wxDefaultSize, 0 );
 585     m_ConfigureButton->SetDefault();
 586     itemBoxSizer26->Add(m_ConfigureButton, 0, wxALIGN_CENTER_VERTICAL|wxALL, 5);
 587
 588     m_OkButton = new wxButton( itemPanel21, ID_DO_OK, _("&Generate!"), wxDefaultPosition, wxDefaultSize, 0 );
 589     itemBoxSizer26->Add(m_OkButton, 0, wxALIGN_CENTER_VERTICAL|wxALL, 5);
 590
 591     m_CancelButton = new wxButton( itemPanel21, ID_DO_CANCEL, _("C&ancel"), wxDefaultPosition, wxDefaultSize, 0 );
 592     itemBoxSizer26->Add(m_CancelButton, 0, wxALIGN_CENTER_VERTICAL|wxALL, 5);
 593
 594 #if defined(__WXMSW__)
 595     wxStaticLine* itemStaticLine30 = new wxStaticLine( itemPanel21, wxID_STATIC, wxDefaultPosition, wxDefaultSize, wxLI_HORIZONTAL );
 596     itemBoxSizer26->Add(itemStaticLine30, 0, wxGROW|wxALL, 5);
 597 #endif
 598
 599     m_DeleteCacheButton = new wxButton( itemPanel21, ID_DO_DELETE_CACHE, _("&Delete Cache"), wxDefaultPosition, wxDefaultSize, 0 );
 600     itemBoxSizer26->Add(m_DeleteCacheButton, 0, wxALIGN_CENTER_VERTICAL|wxALL, 5);
 601
 602     m_ClearLogButton = new wxButton( itemPanel21, ID_CLEAR_LOG, _("Clear &Log"), wxDefaultPosition, wxDefaultSize, 0 );
 603     itemBoxSizer26->Add(m_ClearLogButton, 0, wxALIGN_CENTER_VERTICAL|wxALL, 5);
 604
 605 #if defined(__WXMSW__)
 606     wxStaticLine* itemStaticLine33 = new wxStaticLine( itemPanel21, wxID_STATIC, wxDefaultPosition, wxDefaultSize, wxLI_HORIZONTAL );
 607     itemBoxSizer26->Add(itemStaticLine33, 0, wxGROW|wxALL, 5);
 608 #endif
 609
 610     m_cmBrowseCell = new wxButton( itemPanel21, ID_BROWSE_GRID, _("&Browse"), wxDefaultPosition, wxDefaultSize, 0 );
 611     itemBoxSizer26->Add(m_cmBrowseCell, 0, wxALIGN_CENTER_VERTICAL|wxALL, 5);
 612
 613     m_splitter->SplitHorizontally(itemPanel3, itemPanel21, 300);
 614
 615     wxStatusBar* itemStatusBar35 = new wxStatusBar( itemFrame1, ID_STATUSBAR, wxST_SIZEGRIP|wxNO_BORDER );
 616     itemStatusBar35->SetFieldsCount(2);
 617     itemFrame1->SetStatusBar(itemStatusBar35);
 618
 619 ////@end CMakeSetupFrm content construction
 620 }
 621
 622 void CMakeSetupFrm::DoInitFrame(cmCommandLineInfo &cm, const wxString &fn)
 623 {
 624     // path to where cmake.exe is
 625     // m_PathToExecutable = cm.GetPathToExecutable().c_str();
 626     m_PathToExecutable = fn;
 627
 628     // adjust size of last bar, to display % progress
 629     wxStatusBar *bar = GetStatusBar();
 630     if(bar)
 631     {
 632         wxASSERT(bar->GetFieldsCount() > 1);
 633
 634         // fill all with -1. Why this way? because the count of the status bars
 635         // can change. All of the widths must be accounted for and initialised
 636         int *widths = new int[bar->GetFieldsCount()];
 637         for(int i = 0; i < bar->GetFieldsCount(); i++)
 638             widths[i] = -1;
 639
 640         // the % field
 641         widths[1] = 75;
 642         bar->SetStatusWidths(bar->GetFieldsCount(), widths);
 643         delete widths;
 644     }
 645
 646     wxString name, generator;
 647     std::vector<std::string> names;
 648
 649     m_RunningConfigure = false;
 650
 651     // set grid labels
 652     m_cmOptions->SetColLabelValue(0, wxT("Cache Name"));
 653     m_cmOptions->SetColLabelValue(1, wxT("Cache Value"));
 654     m_cmOptions->SetProjectGenerated(false);
 655
 656     // set drop target
 657     m_cmOptions->SetDropTarget(new DnDFile(m_cmBuildPath));
 658
 659     m_cmake->GetRegisteredGenerators(names);
 660     for(std::vector<std::string>::iterator i = names.begin(); i != names.end(); ++i)
 661     {
 662         name = i->c_str();
 663         m_cmGeneratorChoice->Append(name);
 664     }
 665
 666     // sync advanced option with grid
 667     m_cmOptions->SetShowAdvanced(m_cmShowAdvanced->GetValue());
 668
 669     // if we have a command line query that a generator
 670     // needs to be chosen instead of the default, take it
 671     bool foundGivenGenerator = false;
 672     if(!cm.m_GeneratorChoiceString.IsEmpty())
 673     {
 674         // set proper discovered generator
 675         foundGivenGenerator = m_cmGeneratorChoice->SetStringSelection(cm.m_GeneratorChoiceString);
 676     }
 677
 678     // if none selected, we will see if VS8, VS7 or VS6 is present
 679     if(!foundGivenGenerator || m_cmGeneratorChoice->GetValue().IsEmpty())
 680     {
 681         std::string mp;
 682         mp = "[HKEY_LOCAL_MACHINE\\SOFTWARE\\Microsoft\\VisualStudio\\8.0\\Setup;Dbghelp_path]";
 683         cmSystemTools::ExpandRegistryValues(mp);
 684         if(mp != "/registry")
 685             generator = wxT("Visual Studio 8 2005");
 686         else
 687         {
 688             mp = "[HKEY_LOCAL_MACHINE\\SOFTWARE\\Microsoft\\VisualStudio\\7.1;InstallDir]";
 689             cmSystemTools::ExpandRegistryValues(mp);
 690             if (mp != "/registry")
 691                 generator = wxT("Visual Studio 7 .NET 2003");
 692             else
 693             {
 694                 mp = "[HKEY_LOCAL_MACHINE\\SOFTWARE\\Microsoft\\VisualStudio\\7.0;InstallDir]";
 695                 cmSystemTools::ExpandRegistryValues(mp);
 696                 if (mp != "/registry")
 697                     generator = wxT("Visual Studio 7");
 698                 else
 699                     generator = wxT("Visual Studio 6");
 700             }
 701         }
 702     }
 703
 704     // set proper discovered generator
 705     m_cmGeneratorChoice->SetStringSelection(generator);
 706
 707     wxString str;
 708     str.Printf("CMake %s", cmVersion::GetCMakeVersion());
 709     str.Printf("CMakeSetup v%i.%i%s", CMAKEGUI_MAJORVER, CMAKEGUI_MINORVER, CMAKEGUI_ADDVER);
 710
 711     SetTitle(str);
 712     wxString path;
 713
 714     // get last 5 used projects
 715     for(size_t i = 0; i < CM_MAX_RECENT_PATHS; i++)
 716     {
 717         path.Printf("%s%i", _(CM_RECENT_BUILD_PATH), i);
 718         if(m_config->Read(path, &str))
 719             AppendPathToRecentList(str);
 720     }
 721
 722     // get query items
 723     for(size_t i = 0; i < CM_MAX_SEARCH_QUERIES; i++)
 724     {
 725         path.Printf("%s%i", _(CM_SEARCH_QUERY), i);
 726         if(m_config->Read(path, &str))
 727             m_cmSearchQuery->Append(str);
 728     }
 729
 730
 731     // make sure the call to update grid is not executed
 732     m_noRefresh = true;
 733     m_cmSearchQuery->SetValue(_(""));
 734     m_noRefresh = false;
 735
 736     // Get the parameters from the command line info
 737     // If an unknown parameter is found, try to interpret it too, since it
 738     // is likely to be a file dropped on the shortcut :)
 739     bool sourceDirLoaded = false,
 740          buildDirLoaded = false;
 741
 742     if(cm.m_LastUnknownParameter.empty())
 743     {
 744         if(cm.m_WhereSource.size() > 0 )
 745         {
 746             m_cmProjectPath->SetValue(cm.m_WhereSource.c_str());
 747             sourceDirLoaded = true;
 748         }
 749
 750         if (cm.m_WhereBuild.size() > 0 )
 751         {
 752             m_cmBuildPath->SetValue(cm.m_WhereBuild.c_str());
 753             buildDirLoaded = true;
 754         }
 755
 756         m_cmShowAdvanced->SetValue(cm.m_AdvancedValues);
 757     }
 758     else
 759     {
 760         m_cmShowAdvanced->SetValue(false);
 761
 762         // TODO: Interpret directory from dropped shortcut
 763         //this->ChangeDirectoriesFromFile(cmdInfo->m_LastUnknownParameter.c_str());
 764     }
 765
 766     if (cm.m_ExitAfterLoad)
 767     {
 768         int id = GetId();
 769         m_ExitTimer = new wxTimer(this, id);
 770         m_ExitTimer->Start(3000);
 771
 772         Connect( id, wxEVT_TIMER,(wxObjectEventFunction) &CMakeSetupFrm::OnExitTimer );
 773
 774     }
 775
 776     // retrieve settings, this needs to be done here
 777     // because writing to the m_cmBuildPath triggers a cache reload
 778     if(!sourceDirLoaded && m_config->Read(CM_LASTPROJECT_PATH, &str))
 779         m_cmProjectPath->SetValue(str);
 780
 781     if(!buildDirLoaded)
 782     {
 783         m_cmOptions->RemoveAll();
 784         if(m_config->Read(CM_LASTBUILD_PATH, &str))
 785             m_cmBuildPath->SetValue(str);
 786     }
 787
 788     // set window size from settings
 789     long xsize, ysize, splitpos;
 790     if(m_config->Read(CM_XSIZE, &xsize) && m_config->Read(CM_YSIZE, &ysize) &&
 791        m_config->Read(CM_SPLITTERPOS, &splitpos))
 792     {
 793         SetSize(xsize, ysize);
 794         m_splitter->SetSashPosition(splitpos);
 795     }
 796
 797     if(m_config->Read(CM_XPOS, &xsize) && m_config->Read(CM_YPOS, &ysize))
 798         SetSize(xsize, ysize, -1, -1, wxSIZE_USE_EXISTING);
 799
 800     UpdateWindowState();
 801 }
 802
 803 void CMakeSetupFrm::LoadCacheFromDiskToGUI()
 804 {
 805     wxString builddir = m_cmBuildPath->GetValue();
 806
 807     cmCacheManager *cachem = m_cmake->GetCacheManager();
 808     if(cachem && !builddir.Trim().IsEmpty())
 809     {
 810         if(cachem->LoadCache(builddir.c_str()))
 811             AppendPathToRecentList(builddir);
 812
 813         // represent this cache in the grid, but not before we
 814         // wiped all of the old items
 815         FillCacheGUIFromCacheManager();
 816
 817         // set the generator string to the one used in the cache
 818         cmCacheManager::CacheIterator it = cachem->GetCacheIterator("CMAKE_GENERATOR");
 819         if(!it.IsAtEnd())
 820         {
 821             wxString curGen = it.GetValue();
 822             m_cmGeneratorChoice->SetStringSelection(curGen);
 823         }
 824     }
 825 }
 826
 827 void CMakeSetupFrm::AppendPathToRecentList(const wxString &p)
 828 {
 829     wxFileName path;
 830     wxString str;
 831
 832     if(p.IsEmpty())
 833         return;
 834
 835     // cheap way to get rid of trailing seperators
 836     path.AssignDir(p);
 837     str = path.GetPath();
 838
 839     // append the item, or add it to end to make sure
 840     // it is remembered between sessions
 841     for(size_t i = 0; i < m_recentPaths.Count(); i++)
 842     {
 843         if(m_recentPaths[i].IsSameAs(str, false))
 844         {
 845             m_recentPaths.RemoveAt(i);
 846
 847             // only re-add when item is still valid
 848             if(::wxDirExists(str))
 849                 m_recentPaths.Add(str);
 850             else
 851                 return;  // no add when the item is not existing
 852
 853             return;
 854         }
 855     }
 856
 857     if(GetMenuBar())
 858     {
 859         // get file menu
 860         int lastUsedID = 0;
 861         wxMenu *mnu = GetMenuBar()->GetMenu(0);
 862         wxASSERT(mnu != 0);
 863
 864         if(::wxDirExists(str))
 865         {
 866             // add to array
 867             if(m_recentPaths.Count() == 0)
 868                 mnu->AppendSeparator();
 869
 870             lastUsedID = CM_RECENT_BUILD_ITEM + m_recentPaths.Count();
 871             m_recentPaths.Add(str);
 872
 873             // when we have more in list then we can display, prune and
 874             // remove some menu items until we have room (and available ID's again)
 875             if(m_recentPaths.Count() > CM_MAX_RECENT_PATHS)
 876             {
 877                 // prune the list
 878                 while(m_recentPaths.Count() > CM_MAX_RECENT_PATHS)
 879                     m_recentPaths.RemoveAt(0);
 880
 881                 // now determine count, and remove until we have room
 882                 int index = mnu->GetMenuItemCount() - 1;
 883                 int count = 0;
 884                 wxASSERT(index > 0);
 885
 886                 wxMenuItem *item;
 887                 do
 888                 {
 889                     item = mnu->FindItemByPosition(index);
 890                     if(item)
 891                     {
 892                         if(item->IsSeparator())
 893                         {
 894                             // next index is valid item
 895                             index ++;
 896                             break;
 897                         }
 898                         else
 899                             count ++;
 900                     }
 901
 902                     index --;
 903                 }
 904                 while(index >= 0 && item);
 905
 906                 // ok, if count > CM_MAX_RECENT_PATHS then we are going to
 907                 // delete some items on the index position
 908                 if(count >= CM_MAX_RECENT_PATHS)
 909                 {
 910                     // delete items that are exceeding
 911                     while(count >= CM_MAX_RECENT_PATHS)
 912                     {
 913                         lastUsedID = mnu->FindItemByPosition(index)->GetId();
 914                         mnu->Delete(lastUsedID);
 915                         count --;
 916                     }
 917                 }
 918             }
 919
 920             // append item
 921             mnu->Append(lastUsedID, str);
 922         }
 923     }
 924 }
 925
 926 bool CMakeSetupFrm::PerformCacheRun()
 927 {
 928     bool enable = false;
 929     cmCacheManager *cachem = m_cmake->GetCacheManager();
 930     cmCacheManager::CacheIterator it = cachem->NewIterator();
 931
 932     // remove all items that are no longer present
 933     size_t j = 0;
 934     while(j < m_cmOptions->GetCount())
 935     {
 936         // check to see if it is still in the CMake cache
 937         // if it is still in the cache then it is no longer new
 938         wxPropertyItem *item = m_cmOptions->GetItem(j);
 939         if ( !it.Find((const char*)item->GetPropName().c_str()) )
 940             m_cmOptions->RemoveProperty(item);
 941         else
 942         {
 943             // ok we found it, mark as old
 944             item->SetNewValue(false);
 945             int row = m_cmOptions->FindProperty(item);
 946             if(row != -1)
 947                 m_cmOptions->UpdatePropertyItem(item, row);
 948             j++;
 949         }
 950     }
 951
 952     if(cachem->GetSize() > 0 && !cmSystemTools::GetErrorOccuredFlag())
 953     {
 954         bool enable = true;
 955         for(size_t i = 0; i < m_cmOptions->GetCount(); i++)
 956         {
 957             wxPropertyItem* item = m_cmOptions->GetItem(i);
 958             if(item->GetAdvanced())
 959             {
 960                 if(item->GetNewValue() && m_cmOptions->GetShowAdvanced())
 961                 {
 962                     // if one new value then disable to OK button
 963                     enable = false;
 964                     break;
 965                 }
 966             }
 967             else
 968             {
 969                 if(item->GetNewValue())
 970                 {
 971                     // if one new value then disable to OK button
 972                     enable = false;
 973                     break;
 974                 }
 975             }
 976         }
 977     }
 978
 979     return enable;
 980 }
 981
 982 void CMakeSetupFrm::FillCacheGUIFromCacheManager()
 983 {
 984     cmCacheManager *cachem = m_cmake->GetCacheManager();
 985     cmCacheManager::CacheIterator it = cachem->NewIterator();
 986
 987     // remove all items that are no longer present
 988     size_t j = 0;
 989     while(j < m_cmOptions->GetCount())
 990     {
 991         // check to see if it is still in the CMake cache
 992         // if it is still in the cache then it is no longer new
 993         wxPropertyItem *item = m_cmOptions->GetItem(j);
 994         if ( !it.Find((const char*)item->GetPropName().c_str()) )
 995             m_cmOptions->RemoveProperty(item);
 996         else
 997             j++;
 998     }
 999
1000     // if there are already entries in the cache, then
1001     // put the new ones in the top, so they show up first
1002     bool reverseOrder = false;
1003     for(cmCacheManager::CacheIterator i = cachem->NewIterator(); !i.IsAtEnd(); i.Next())
1004     {
1005         const char* key = i.GetName();
1006
1007         // if value has trailing space or tab, enclose it in single quotes
1008         // to enforce the fact that it has 'invisible' trailing stuff
1009         std::string value = i.GetValue();
1010         if (value.size() && (value[value.size() - 1] == ' ' ||  value[value.size() - 1] == '\t'))
1011             value = '\'' + value +  '\'';
1012
1013         bool advanced = i.GetPropertyAsBool("ADVANCED");
1014         switch(i.GetType() )
1015         {
1016         case cmCacheManager::BOOL:
1017             {
1018                 wxString OnOff;
1019
1020                 if(cmSystemTools::IsOn(value.c_str()))
1021                     OnOff = wxT("ON");
1022                 else
1023                     OnOff = wxT("OFF");
1024
1025                 m_cmOptions->AddProperty(key,
1026                                          OnOff.c_str(),
1027                                          i.GetProperty("HELPSTRING"),
1028                                          wxPropertyList::CHECKBOX, "ON|OFF",
1029                                          reverseOrder,
1030                                          advanced );
1031             }
1032             break;
1033
1034         case cmCacheManager::PATH:
1035             m_cmOptions->AddProperty(key,
1036                                      value.c_str(),
1037                                      i.GetProperty("HELPSTRING"),
1038                                      wxPropertyList::PATH,"",
1039                                      reverseOrder, advanced);
1040             break;
1041
1042         case cmCacheManager::FILEPATH:
1043             m_cmOptions->AddProperty(key,
1044                                      value.c_str(),
1045                                      i.GetProperty("HELPSTRING"),
1046                                      wxPropertyList::FILE,"",
1047                                      reverseOrder, advanced);
1048             break;
1049
1050         case cmCacheManager::STRING:
1051             m_cmOptions->AddProperty(key,
1052                                      value.c_str(),
1053                                      i.GetProperty("HELPSTRING"),
1054                                      wxPropertyList::EDIT,"",
1055                                      reverseOrder, advanced);
1056             break;
1057
1058         case cmCacheManager::INTERNAL:
1059             {
1060                 wxPropertyItem *pItem = m_cmOptions->FindPropertyByName(key);
1061                 if(pItem)
1062                     m_cmOptions->RemoveProperty(pItem);
1063             }
1064             break;
1065         }
1066     }
1067 }
1068
1069 void CMakeSetupFrm::OnExitTimer(wxTimerEvent &event)
1070 {
1071     Close();
1072 }
1073
1074 /*!
1075  * wxEVT_COMMAND_BUTTON_CLICKED event handler for ID_BROWSE_PROJECT
1076  */
1077
1078 void CMakeSetupFrm::OnButtonBrowseProject( wxCommandEvent& event )
1079 {
1080     const wxString& dir = wxDirSelector("Select project directory", m_cmProjectPath->GetValue());
1081     if(!dir.IsEmpty())
1082         m_cmProjectPath->SetValue(dir);
1083 }
1084
1085 /*!
1086  * wxEVT_COMMAND_BUTTON_CLICKED event handler for ID_BROWSE_BUILD
1087  */
1088
1089 void CMakeSetupFrm::OnButtonBrowseBuild( wxCommandEvent& event )
1090 {
1091     const wxString& dir = wxDirSelector("Select build directory", m_cmBuildPath->GetValue());
1092     if(!dir.IsEmpty())
1093         m_cmBuildPath->SetValue(dir);
1094 }
1095
1096 /*!
1097  * wxEVT_COMMAND_CHECKBOX_CLICKED event handler for ID_SHOW_ADVANCED
1098  */
1099
1100 void CMakeSetupFrm::OnShowAdvancedValues( wxCommandEvent& event )
1101 {
1102     if(m_cmShowAdvanced->GetValue())
1103         m_cmOptions->ShowAdvanced();
1104     else
1105         m_cmOptions->HideAdvanced();
1106 }
1107
1108 /*!
1109  * wxEVT_COMMAND_BUTTON_CLICKED event handler for ID_DO_CONFIGURE
1110  */
1111
1112 void CMakeSetupFrm::OnButtonConfigure( wxCommandEvent& event )
1113 {
1114     DoConfigure();
1115 }
1116
1117 void CMakeSetupFrm::DoConfigure()
1118 {
1119     // enable error messages each time configure is pressed
1120     cmSystemTools::EnableMessages();
1121     m_cmOptions->HideControls();
1122
1123     cmSystemTools::ResetErrorOccuredFlag();
1124
1125     // instantiate a dialog for the progress meter
1126
1127     PerformCacheRun();
1128     RunCMake(false);
1129 }
1130
1131 int CMakeSetupFrm::RunCMake(bool generateProjectFiles)
1132 {
1133     int value = -1;
1134
1135     // clear log
1136     m_cmLog->Clear();
1137     m_cmLog->DiscardEdits();
1138
1139     wxString builddir = m_cmBuildPath->GetValue(),
1140              sourcedir = m_cmProjectPath->GetValue(),
1141              err = wxT("Error in configuration process, project files may be invalid");
1142
1143
1144     // sanity check for people pressing OK on empty dirs
1145     if(builddir.Trim().IsEmpty() || sourcedir.Trim().IsEmpty())
1146     {
1147         wxMessageBox(wxT("Please enter a valid source directory and build directory"), wxT("Error"), wxOK | wxICON_ERROR, this);
1148         return -1;
1149     }
1150
1151     // check if the directory exists, if not, create it
1152     if(!cmSystemTools::FileExists(builddir.c_str()))
1153     {
1154         wxString str;
1155         str << wxT("Build directory does not exist, should I create it?\n\nDirectory: ") << builddir;
1156
1157         int answer = wxMessageBox(str, wxT("Create directory"), wxYES_NO, this);
1158         if (answer == wxYES)
1159         {
1160             if(!cmSystemTools::MakeDirectory(builddir.c_str()))
1161             {
1162                 // could not create, tell and abort
1163                 wxMessageBox(wxT("Could not create directory"), wxT("Error"), wxOK | wxICON_ERROR, this);
1164                 return -1;
1165             }
1166         }
1167         else
1168         {
1169             // we abort because the user did not want to make the directory
1170             wxMessageBox(wxT("Build Project aborted, nothing done."), wxT("Aborted"),
1171                          wxOK | wxICON_EXCLAMATION, this);
1172             return -1;
1173         }
1174     }
1175
1176     /** show progress dialog that informs the user with a progress bar */
1177     if(m_progressDlg)
1178         m_progressDlg->Destroy();
1179
1180     m_progressDlg = new CMProgressDialog(this);
1181     m_progressDlg->Show();
1182
1183     // set the wait cursor
1184     m_RunningConfigure = true;
1185     UpdateWindowState();
1186
1187     // always save the current gui values to disk
1188     SaveCacheFromGUI();
1189
1190     // Make sure we are working from the cache on disk
1191     LoadCacheFromDiskToGUI();
1192
1193     // setup the cmake instance
1194     if (generateProjectFiles)
1195     {
1196         if(m_cmake->Generate() != 0)
1197         {
1198             wxMessageBox(err, wxT("Error"), wxOK | wxICON_ERROR, this);
1199             cmSystemTools::Error(err.c_str());
1200             value = -1;
1201         }
1202         else
1203         {
1204             value = 0;
1205             m_cmOptions->SetProjectGenerated(true); // clear cache dirty when generated
1206         }
1207     }
1208     else
1209     {
1210         // set paths
1211         m_cmake->SetHomeDirectory(m_cmProjectPath->GetValue().c_str());
1212         m_cmake->SetStartDirectory(m_cmProjectPath->GetValue().c_str());
1213         m_cmake->SetHomeOutputDirectory(m_cmBuildPath->GetValue().c_str());
1214         m_cmake->SetStartOutputDirectory(m_cmBuildPath->GetValue().c_str());
1215
1216         m_cmake->SetGlobalGenerator(m_cmake->CreateGlobalGenerator(m_cmGeneratorChoice->GetValue().c_str()));
1217         m_cmake->SetCMakeCommand(m_PathToExecutable.c_str());
1218         m_cmake->LoadCache();
1219         if(m_cmake->Configure() != 0)
1220         {
1221             wxMessageBox(err, wxT("Error"), wxOK | wxICON_ERROR, this);
1222             cmSystemTools::Error(err.c_str());
1223         }
1224
1225         // update the GUI with any new values in the caused by the
1226         // generation process
1227         LoadCacheFromDiskToGUI();
1228     }
1229
1230     m_RunningConfigure = false;
1231
1232     if(!value)
1233         cmSystemTools::ResetErrorOccuredFlag();
1234
1235     m_progressDlg->Destroy();
1236     m_progressDlg = 0;
1237
1238     // reset the statusbar progress
1239     wxStatusBar *bar = GetStatusBar();
1240     if(bar)
1241         bar->SetStatusText(wxEmptyString, 1);
1242
1243     UpdateWindowState();
1244     return value;
1245 }
1246
1247 //! Save GUI values to cmCacheManager and then save to disk.
1248 void CMakeSetupFrm::SaveCacheFromGUI()
1249 {
1250     cmCacheManager *cachem = m_cmake->GetCacheManager();
1251     FillCacheManagerFromCacheGUI();
1252
1253     // write the cache to disk
1254     if(!m_cmBuildPath->GetValue().Trim().IsEmpty())
1255         cachem->SaveCache(m_cmBuildPath->GetValue().c_str());
1256 }
1257
1258 void CMakeSetupFrm::FillCacheManagerFromCacheGUI()
1259 {
1260     cmCacheManager *cachem = m_cmake->GetCacheManager();
1261
1262     cmCacheManager::CacheIterator it = cachem->NewIterator();
1263     for(size_t i = 0; i < m_cmOptions->GetCount(); i++)
1264     {
1265         wxPropertyItem* item = m_cmOptions->GetItem(i);
1266         if ( it.Find((const char*)item->GetPropName().c_str()) )
1267         {
1268             // if value is enclosed in single quotes ('foo') then remove them
1269             // they were used to enforce the fact that it had 'invisible'
1270             // trailing stuff
1271             if (item->GetCurValue().Len() >= 2 &&
1272                 item->GetCurValue().GetChar(0) == '\'' &&
1273                 item->GetCurValue().GetChar(item->GetCurValue().Len() - 1) == '\'')
1274             {
1275                 it.SetValue(item->GetCurValue().Mid(1, item->GetCurValue().Len() - 2).c_str());
1276             }
1277             else
1278                 it.SetValue(item->GetCurValue().c_str());
1279         }
1280     }
1281 }
1282
1283
1284 /*!
1285  * wxEVT_COMMAND_BUTTON_CLICKED event handler for ID_DO_OK
1286  */
1287
1288 void CMakeSetupFrm::OnButtonOk( wxCommandEvent& event )
1289 {
1290     DoGenerate();
1291 }
1292
1293 void CMakeSetupFrm::DoGenerate()
1294 {
1295     cmSystemTools::EnableMessages();
1296
1297     cmSystemTools::ResetErrorOccuredFlag();
1298
1299     m_cmOptions->HideControls();
1300     PerformCacheRun();
1301
1302     if(!RunCMake(true))
1303     {
1304         // issue a close when this is done (this is issued by menu "Generate and Exit"
1305         if(m_quitAfterGenerating)
1306             Close();
1307         else if(!wxGetKeyState(WXK_SHIFT))
1308         {
1309             bool close;
1310             m_config->Read(CM_CLOSEAFTERGEN, &close, CM_CLOSEAFTERGEN_DEF);
1311
1312             if(!close)
1313                 wxMessageBox(wxT("Building of project files succesful!"), wxT("Success!"), wxOK|wxICON_INFORMATION);
1314             else
1315                 Close();
1316         }
1317     }
1318 }
1319
1320 /*!
1321  * wxEVT_COMMAND_BUTTON_CLICKED event handler for ID_DO_CANCEL
1322  */
1323
1324 void CMakeSetupFrm::OnButtonCancel( wxCommandEvent& event )
1325 {
1326     DoCancelButton();
1327 }
1328
1329 void CMakeSetupFrm::DoCancelButton()
1330 {
1331     if(m_RunningConfigure)
1332     {
1333         int result = wxMessageBox(wxT("You are in the middle of a Configure.\n"
1334                                       "If you Cancel now the configure information will be lost.\n"
1335                                       "Are you sure you want to Cancel?"), wxT("Warning"), wxYES_NO|wxICON_WARNING);
1336         if(result == wxYES)
1337             cmSystemTools::SetFatalErrorOccured();
1338         else
1339             if(m_progressDlg)
1340                 m_progressDlg->ResetCancel();
1341     }
1342 }
1343
1344 /*!
1345  * wxEVT_COMMAND_BUTTON_CLICKED event handler for ID_DO_DELETE_CACHE
1346  */
1347
1348 void CMakeSetupFrm::OnButtonDeleteCache( wxCommandEvent& event )
1349 {
1350     DoDeleteCache();
1351 }
1352
1353 void CMakeSetupFrm::DoDeleteCache()
1354 {
1355     bool deletecache = true;
1356     if(m_cmOptions->IsCacheDirty() || (m_cmOptions->GetCount() > 0 && !m_cmOptions->IsGenerated()))
1357     {
1358         int result = ::wxMessageBox(_("You have changed options, are you sure you want to delete all items?\n"),
1359                                     _("Warning"), wxYES_NO|wxICON_QUESTION);
1360
1361         // when user wants to wait, wait.. else quit
1362         if(result == wxNO)
1363             deletecache = false;
1364
1365     }
1366
1367     if(deletecache)
1368     {
1369         // indicate that we haven't generated a project yet
1370         m_cmOptions->SetProjectGenerated(false);
1371
1372         if(!m_cmBuildPath->GetValue().Trim().IsEmpty() && m_cmake != 0)
1373             m_cmake->GetCacheManager()->DeleteCache(m_cmBuildPath->GetValue().Trim());
1374
1375         LoadCacheFromDiskToGUI();
1376         UpdateWindowState();
1377     }
1378 }
1379
1380 /*!
1381  * Should we show tooltips?
1382  */
1383
1384 bool CMakeSetupFrm::ShowToolTips()
1385 {
1386     return TRUE;
1387 }
1388
1389 /*!
1390  * Get bitmap resources
1391  */
1392
1393 wxBitmap CMakeSetupFrm::GetBitmapResource( const wxString& name )
1394 {
1395     // Bitmap retrieval
1396 ////@begin CMakeSetupFrm bitmap retrieval
1397     return wxNullBitmap;
1398 ////@end CMakeSetupFrm bitmap retrieval
1399 }
1400
1401 /*!
1402  * Get icon resources
1403  */
1404
1405 wxIcon CMakeSetupFrm::GetIconResource( const wxString& name )
1406 {
1407     // Icon retrieval
1408 ////@begin CMakeSetupFrm icon retrieval
1409     if (name == wxT("cmake_icon.xpm"))
1410     {
1411         wxIcon icon(_T("cmake_icon.xpm"), wxBITMAP_TYPE_XPM);
1412         return icon;
1413     }
1414     return wxNullIcon;
1415 ////@end CMakeSetupFrm icon retrieval
1416 }
1417
1418 /*!
1419  * wxEVT_COMMAND_SPLITTER_SASH_POS_CHANGING event handler for ID_SPLITTERWINDOW
1420  */
1421
1422 void CMakeSetupFrm::OnSplitterPosChanging( wxSplitterEvent& event )
1423 {
1424     int width, height;
1425
1426     GetSize(&width, &height);
1427
1428     if((height > 100))
1429     {
1430         if(event.GetSashPosition() < 170)
1431             event.SetSashPosition(170);
1432         else
1433         {
1434             if(event.GetSashPosition() > (height - 180))
1435                 event.SetSashPosition(height - 180);
1436         }
1437     }
1438     else
1439         event.Veto();
1440
1441 }
1442
1443
1444 /*!
1445  * wxEVT_COMMAND_BUTTON_CLICKED event handler for ID_CLEAR_LOG
1446  */
1447
1448 void CMakeSetupFrm::OnClearLogClick( wxCommandEvent& event )
1449 {
1450     // delete the log text
1451     m_cmLog->Clear();
1452     m_cmLog->DiscardEdits();
1453 }
1454
1455
1456 /*!
1457  * wxEVT_COMMAND_TEXT_UPDATED event handler for ID_SOURCE_BUILD_PATH
1458  */
1459
1460 void CMakeSetupFrm::OnSourceBuildPathUpdated( wxCommandEvent& event )
1461 {
1462     DoReloadCache();
1463 }
1464
1465 void CMakeSetupFrm::DoReloadCache()
1466 {
1467     wxString buildpath = m_cmBuildPath->GetValue();
1468     // The build dir has changed, check if there is a cache, and
1469     // grab the source dir from it
1470
1471     // make sure the call to update grid is not executed
1472     m_noRefresh = true;
1473     m_cmSearchQuery->SetValue(_(""));
1474     m_noRefresh = false;
1475
1476     std::string path = buildpath.c_str();
1477     cmSystemTools::ConvertToUnixSlashes(path);
1478
1479     // adjust the cmake instance
1480     m_cmake->SetHomeOutputDirectory(buildpath.c_str());
1481     m_cmake->SetStartOutputDirectory(buildpath.c_str());
1482
1483     std::string cache_file = path;
1484     cache_file += "/CMakeCache.txt";
1485
1486     // fill in the project path where the source is located, this is
1487     // read from the CMake cache
1488     cmCacheManager *cachem = m_cmake->GetCacheManager();
1489     cmCacheManager::CacheIterator it = cachem->NewIterator();
1490     if (cmSystemTools::FileExists(cache_file.c_str()) && cachem->LoadCache(path.c_str()) &&
1491         it.Find("CMAKE_HOME_DIRECTORY"))
1492     {
1493         path = ConvertToWindowsPath(it.GetValue());
1494         m_cmProjectPath->SetValue(path.c_str());
1495     }
1496
1497     m_cmOptions->RemoveAll();
1498     LoadCacheFromDiskToGUI();
1499     UpdateWindowState();
1500 }
1501
1502
1503 /*!
1504  * wxEVT_COMMAND_TEXT_ENTER event handler for ID_SOURCE_BUILD_PATH
1505  */
1506
1507 void CMakeSetupFrm::OnSourceBuildPathEnter( wxCommandEvent& event )
1508 {
1509     OnSourceBuildPathUpdated(event);
1510 }
1511
1512 /*!
1513  * wxEVT_MOTION event handler for ID_OPTIONS
1514  */
1515
1516 void CMakeSetupFrm::OnPropertyMotion( wxMouseEvent& event )
1517 {
1518     ShowPropertyDescription(m_cmOptions->YToRow(event.GetY()));
1519     event.Skip();
1520 }
1521
1522
1523 /*!
1524  * wxEVT_GRID_SELECT_CELL event handler for ID_OPTIONS
1525  */
1526
1527 void CMakeSetupFrm::OnGridSelectCell( wxGridEvent& event )
1528 {
1529     // show description
1530     ShowPropertyDescription(event.GetRow());
1531
1532     // enable or disable the browse button
1533     m_cmBrowseCell->Enable(m_cmOptions->IsSelectedItemBrowsable(event.GetRow()));
1534     event.Skip();
1535 }
1536
1537 void CMakeSetupFrm::ShowPropertyDescription(int row)
1538 {
1539     if(row == wxNOT_FOUND || row < 0)
1540         m_cmDescription->SetValue(wxEmptyString);
1541     else
1542     {
1543         wxPropertyItem *pItem = m_cmOptions->GetPropertyItemFromRow(row);
1544         if(pItem)
1545             m_cmDescription->SetValue(pItem->GetHelpString());
1546         else
1547             m_cmDescription->SetValue(wxEmptyString);
1548     }
1549 }
1550
1551 /*!
1552  * wxEVT_GRID_CELL_CHANGE event handler for ID_OPTIONS
1553  */
1554
1555 void CMakeSetupFrm::OnCellChange( wxGridEvent& event )
1556 {
1557     // update the button state when the cache is invalidated
1558     UpdateWindowState();
1559 }
1560
1561 void CMakeSetupFrm::OnRecentFileMenu( wxCommandEvent &event )
1562 {
1563     if(GetMenuBar())
1564     {
1565         // get file menu
1566         wxMenu *mnu = GetMenuBar()->GetMenu(0);
1567         wxASSERT(mnu != 0);
1568
1569         wxMenuItem *item = mnu->FindItem(event.GetId());
1570         if(item)
1571             m_cmBuildPath->SetValue(item->GetLabel());
1572     }
1573 }
1574 /*!
1575  * wxEVT_COMMAND_COMBOBOX_SELECTED event handler for ID_COMBOBOX
1576  */
1577
1578 void CMakeSetupFrm::OnSearchquerySelected( wxCommandEvent& event )
1579 {
1580     m_cmOptions->SetQuery(m_cmSearchQuery->GetValue());
1581 }
1582
1583 void CMakeSetupFrm::OnAddQuery ( wxCommandEvent &event )
1584 {
1585     // add current text if not yet present
1586     if(m_cmSearchQuery->FindString(m_cmSearchQuery->GetValue()) == wxNOT_FOUND)
1587     {
1588         m_cmSearchQuery->Append(m_cmSearchQuery->GetValue());
1589
1590         // if too many items are present, prune
1591         while(m_cmSearchQuery->GetCount() > CM_MAX_SEARCH_QUERIES)
1592             m_cmSearchQuery->Delete(0);
1593     }
1594 }
1595
1596 /*!
1597  * wxEVT_COMMAND_TEXT_UPDATED event handler for ID_SEARCHQUERY
1598  */
1599
1600 void CMakeSetupFrm::OnSearchqueryUpdated( wxCommandEvent& event )
1601 {
1602     // only refresh when this event was caused by user
1603     if(!m_noRefresh)
1604         m_cmOptions->SetQuery(m_cmSearchQuery->GetValue());
1605 }
1606
1607
1608 /*!
1609  * wxEVT_COMMAND_BUTTON_CLICKED event handler for ID_BROWSE_GRID
1610  */
1611
1612 void CMakeSetupFrm::OnBrowseGridClick( wxCommandEvent& event )
1613 {
1614     m_cmOptions->BrowseSelectedItem();
1615 }
1616
1617
1618 /*!
1619  * wxEVT_COMMAND_MENU_SELECTED event handler for ID_MENU_RELOAD_CACHE
1620  */
1621
1622 void CMakeSetupFrm::OnMenuReloadCacheClick( wxCommandEvent& event )
1623 {
1624     bool reload = true;
1625     if(m_cmOptions->IsCacheDirty() || (m_cmOptions->GetCount() > 0 && !m_cmOptions->IsGenerated()))
1626     {
1627         int result = ::wxMessageBox(_("You have changed options, are you sure you want to reload?\n"),
1628                                     _("Warning"), wxYES_NO|wxICON_QUESTION);
1629
1630         // when user wants to wait, wait.. else quit
1631         if(result == wxNO)
1632             reload = false;
1633
1634     }
1635
1636     if(reload)
1637         DoReloadCache();
1638 }
1639
1640 /*!
1641  * wxEVT_COMMAND_MENU_SELECTED event handler for ID_MENU_DELETE_CACHE
1642  */
1643
1644 void CMakeSetupFrm::OnMenuDeleteCacheClick( wxCommandEvent& event )
1645 {
1646     DoDeleteCache();
1647 }
1648
1649
1650 /*!
1651  * wxEVT_COMMAND_MENU_SELECTED event handler for ID_MENU_QUIT
1652  */
1653
1654 void CMakeSetupFrm::OnMenuQuitClick( wxCommandEvent& event )
1655 {
1656     // the close event will veto if the user
1657     // did not want to quit due to unsaved changes
1658     Close();
1659 }
1660
1661
1662 /*!
1663  * wxEVT_CLOSE_WINDOW event handler for ID_FRAME
1664  */
1665
1666 void CMakeSetupFrm::OnCloseWindow( wxCloseEvent& event )
1667 {
1668     // ask quit if:
1669     //  - The cache is dirty
1670     //  - Or the cache is OK and has some items, and no project was generated recently (configure -> generate)
1671     if(m_cmOptions->IsCacheDirty() || (m_cmOptions->GetCount() > 0 && !m_cmOptions->IsGenerated()))
1672     {
1673         int result = ::wxMessageBox(_("You have changed options, but not yet generated the projects\n"
1674                                       "are you sure you want to quit?"), _("Warning"), wxYES_NO|wxICON_QUESTION);
1675
1676         // when user wants to wait, wait.. else quit
1677         if(result == wxNO)
1678             event.Veto();
1679         else
1680             event.Skip();
1681     }
1682     else
1683         event.Skip();
1684 }
1685
1686
1687 /*!
1688  * wxEVT_COMMAND_MENU_SELECTED event handler for ID_ABOUTDLG
1689  */
1690
1691 void CMakeSetupFrm::OnAboutClick( wxCommandEvent& event )
1692 {
1693     CMAboutDlg *dlg = new CMAboutDlg(this);
1694
1695     wxArrayString generators;
1696     std::vector<std::string> names;
1697     m_cmake->GetRegisteredGenerators(names);
1698     for(std::vector<std::string>::iterator i = names.begin(); i != names.end(); ++i)
1699         generators.Add(i->c_str());
1700
1701     wxString cmversion, cmsversion;
1702     cmsversion.Printf("v%i.%i%s", CMAKEGUI_MAJORVER, CMAKEGUI_MINORVER, CMAKEGUI_ADDVER);
1703
1704     dlg->SetAboutText(cmversion, cmsversion, generators);
1705
1706     dlg->ShowModal();
1707     dlg->Destroy();
1708 }
1709
1710
1711 /*!
1712  * wxEVT_COMMAND_MENU_SELECTED event handler for ID_CMAKE_OPTIONS
1713  */
1714
1715 void CMakeSetupFrm::OnOptionsClick( wxCommandEvent& event )
1716 {
1717     CMOptionsDlg *dlg = new CMOptionsDlg(this);
1718
1719     dlg->SetConfig(m_config);
1720     if(dlg->ShowModal() == wxID_OK)
1721     {
1722         // store volatile settings
1723         dlg->GetConfig(m_config);
1724
1725         // apply non volatile setting such as clear search query, recent menu, etc.
1726         SyncFormOptions(dlg);
1727     }
1728
1729     dlg->Destroy();
1730 }
1731
1732 void CMakeSetupFrm::SyncFormOptions(CMOptionsDlg *dlg)
1733 {
1734     // TODO: Clear search query etc.
1735 }
1736 /*!
1737  * wxEVT_COMMAND_SPLITTER_DOUBLECLICKED event handler for ID_SPLITTERWINDOW
1738  */
1739
1740 void CMakeSetupFrm::OnSplitterwindowSashDClick( wxSplitterEvent& event )
1741 {
1742     event.Veto();
1743 }
1744
1745
1746 /*!
1747  * wxEVT_COMMAND_MENU_SELECTED event handler for ID_MENU_CONFIGURE
1748  */
1749
1750 void CMakeSetupFrm::OnMenuConfigureClick( wxCommandEvent& event )
1751 {
1752     DoConfigure();
1753 }
1754
1755 /*!
1756  * wxEVT_COMMAND_MENU_SELECTED event handler for ID_MENU_EXITGENERATE
1757  */
1758
1759 void CMakeSetupFrm::OnMenuGenerateClick( wxCommandEvent& event )
1760 {
1761     // set flag so that a close command is issued
1762     // after generating the cmake cache to projects
1763     m_quitAfterGenerating = true;
1764     DoGenerate();
1765     m_quitAfterGenerating = false;
1766 }
1767
1768
1769 /*!
1770  * wxEVT_COMMAND_MENU_SELECTED event handler for ID_MENU_TOGGLE_ADVANCED
1771  */
1772
1773 void CMakeSetupFrm::OnMenuToggleAdvancedClick( wxCommandEvent& event )
1774 {
1775     // toggle the check box
1776     m_cmShowAdvanced->SetValue(!m_cmShowAdvanced->GetValue());
1777     OnShowAdvancedValues(event);
1778 }
1779
1780