ENH: try to find a gui for the Mac

1 files changed, 838 insertions, 0 deletions

diff --git a/Source/FLTKDialog/CMakeSetupGUIImplementation.cxx b/Source/FLTKDialog/CMakeSetupGUIImplementation.cxx
new file mode 100644
index 0000000..5e42f09
--- /dev/null
+++ b/Source/FLTKDialog/CMakeSetupGUIImplementation.cxx
@@ -0,0 +1,838 @@
+/*=========================================================================
+
+  Program:   Insight Segmentation & Registration Toolkit
+  Module:    $RCSfile$
+  Language:  C++
+  Date:      $Date$
+  Version:   $Revision$
+
+  Copyright (c) 2002 Insight Consortium. All rights reserved.
+  See ITKCopyright.txt or http://www.itk.org/HTML/Copyright.htm 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.
+
+=========================================================================*/
+
+#include "CMakeSetupGUIImplementation.h"
+#include "FL/fl_file_chooser.H"
+#include "FL/filename.H"
+#include "FL/fl_ask.H"
+#include "../cmCacheManager.h"
+#include "../cmMakefile.h"
+#include <iostream>
+#include "FLTKPropertyList.h"
+#include "FLTKPropertyItemRow.h"
+#include "FL/fl_draw.H"
+#include "../cmake.h"
+
+void FLTKMessageCallback(const char* message, const char* title, bool& nomore, void*)
+{
+  std::string msg = message;
+  msg += "\nPress cancel to suppress any further messages.";
+  int choice = fl_choice( msg.c_str(), "Cancel","Ok",0);
+  if(choice==0)
+    {
+    nomore = true;
+    }
+}
+
+/**
+ * Constructor
+ */
+CMakeSetupGUIImplementation
+::CMakeSetupGUIImplementation():m_CacheEntriesList(this)
+{
+  m_CMakeInstance = new cmake;
+  cmSystemTools::SetErrorCallback(FLTKMessageCallback);
+  m_BuildPathChanged = false;
+}
+
+
+
+/**
+ * Destructor
+ */
+CMakeSetupGUIImplementation
+::~CMakeSetupGUIImplementation()
+{
+}
+
+
+
+
+/**
+ * Show the graphic interface
+ */
+void
+CMakeSetupGUIImplementation
+::Show( void )
+{
+  dialogWindow->show();
+}
+
+
+
+
+
+/**
+ * Hide the graphic interface
+ */
+void
+CMakeSetupGUIImplementation
+::Close( void )
+{
+  SaveRecentDirectories();
+  dialogWindow->hide();
+}
+
+
+
+
+
+/**
+ * Browse for the path to the sources
+ */
+void
+CMakeSetupGUIImplementation
+::BrowseForSourcePath( void )
+{
+  const char * path = 
+                  fl_dir_chooser(
+                    "Path to Sources",
+                    sourcePathTextInput->value() );
+                    
+  if( !path )
+  {
+    return;
+  }
+  
+  SetSourcePath( path );
+
+}
+
+
+
+
+/**
+ * Browse for the path to the binaries
+ */
+void
+CMakeSetupGUIImplementation
+::BrowseForBinaryPath( void )
+{
+  const char * path = 
+                  fl_dir_chooser(
+                    "Path to Binaries",
+                    binaryPathTextInput->value() );
+                    
+  if( !path )
+  {
+    return;
+  }
+
+  SetBinaryPath( path );
+
+}
+
+
+
+
+
+/**
+ * Set path to executable. Used to get the path to CMake
+ */
+void
+CMakeSetupGUIImplementation
+::SetPathToExecutable( const char * path )
+{
+  m_PathToExecutable = cmSystemTools::CollapseFullPath(path);
+  m_PathToExecutable = cmSystemTools::GetProgramPath(m_PathToExecutable.c_str()).c_str();
+#ifdef _WIN32
+  m_PathToExecutable += "/cmake.exe";
+#else
+  m_PathToExecutable += "/cmake";
+#endif
+}
+
+
+
+/**
+ * Set the source path
+ */
+void
+CMakeSetupGUIImplementation
+::SetSourcePath( const char * path )
+{
+
+  if( !path || strlen(path)==0 )
+  {
+    fl_alert("Please select the path to the sources");
+    return;
+  }
+
+  std::string expandedAbsolutePath = ExpandPathAndMakeItAbsolute( path );
+  
+  sourcePathTextInput->value( expandedAbsolutePath.c_str() );
+    
+  if( VerifySourcePath( expandedAbsolutePath ) )
+  {
+    m_WhereSource = expandedAbsolutePath;
+  }
+
+}
+
+
+
+
+/**
+ * Expand environment variables in the path and make it absolute
+ */
+std::string
+CMakeSetupGUIImplementation
+::ExpandPathAndMakeItAbsolute( const std::string & inputPath ) const
+{
+  return cmSystemTools::CollapseFullPath(inputPath.c_str());
+}
+
+
+/**
+ * Set the binary path
+ */
+void
+CMakeSetupGUIImplementation
+::SetBinaryPath( const char * path )
+{
+
+  if( !path || strlen(path)==0 )
+  {
+    fl_alert("Please select the path to the binaries");
+    return;
+  }
+
+  std::string expandedAbsolutePath = ExpandPathAndMakeItAbsolute( path );
+  
+  binaryPathTextInput->value( expandedAbsolutePath.c_str() );
+
+  if( !VerifyBinaryPath( expandedAbsolutePath.c_str() ) )
+  {
+  return;
+  }
+
+  if( m_WhereBuild != expandedAbsolutePath )
+  {
+    m_BuildPathChanged  = true;
+    m_WhereBuild        = expandedAbsolutePath;
+    m_CacheEntriesList.RemoveAll(); // remove data from other project
+    this->LoadCacheFromDiskToGUI();
+  }
+  else 
+  {
+    m_BuildPathChanged = false;
+  }
+  
+
+}
+
+
+
+/**
+ * Verify the path to binaries
+ */
+bool
+CMakeSetupGUIImplementation
+::VerifyBinaryPath( const std::string & path ) const
+{
+
+  bool pathIsOK = false;
+
+  if( cmSystemTools::FileIsDirectory( path.c_str() ) )
+    {
+    pathIsOK = true;
+    }
+  else
+    {
+    int userWantsToCreateDirectory = 
+      fl_ask("The directory \n %s \n Doesn't exist. Do you want to create it ?",
+              path.c_str() );
+    
+    if( userWantsToCreateDirectory  )
+      {
+      cmSystemTools::MakeDirectory( path.c_str() );
+      pathIsOK = true;
+      }
+    else
+      {
+      pathIsOK = false; 
+      }
+    }
+  
+  return pathIsOK;
+
+}
+
+
+
+/**
+ * Verify the path to sources
+ */
+bool
+CMakeSetupGUIImplementation
+::VerifySourcePath( const std::string & path ) const
+{
+
+  if( !cmSystemTools::FileIsDirectory(( path.c_str())))
+    {
+    fl_alert("The Source directory \n %s \n Doesn't exist or is not a directory", path.c_str() );
+    return false; 
+    }
+  
+  return true;
+}
+
+
+
+
+/**
+ * Build the project files
+ */
+void
+CMakeSetupGUIImplementation
+::RunCMake( bool generateProjectFiles )
+{
+
+  if(!cmSystemTools::FileIsDirectory( m_WhereBuild.c_str() ))
+    {
+    std::string message =
+      "Build directory does not exist, should I create it?\n\n"
+      "Directory: ";
+    message += m_WhereBuild;
+    int userWantToCreateDirectory =
+      fl_ask(message.c_str());
+    if( userWantToCreateDirectory )
+      {
+      cmSystemTools::MakeDirectory( m_WhereBuild.c_str() );
+      }
+    else
+      {
+      fl_alert("Build Project aborted, nothing done.");
+      return;
+      }
+    }
+
+  
+  // set the wait cursor
+  fl_cursor(FL_CURSOR_WAIT,FL_BLACK,FL_WHITE);
+
+
+  // save the current GUI values to the cache
+  this->SaveCacheFromGUI();
+
+  // Make sure we are working from the cache on disk
+  this->LoadCacheFromDiskToGUI();
+
+  UpdateListOfRecentDirectories();
+  SaveRecentDirectories();
+  if (generateProjectFiles)
+    {
+    if(m_CMakeInstance->Generate() != 0)
+      {
+      cmSystemTools::Error(
+        "Error in generation process, project files may be invalid");
+      }
+    }
+  else
+    {
+    m_CMakeInstance->SetHomeDirectory(m_WhereSource.c_str());
+    m_CMakeInstance->SetStartDirectory(m_WhereSource.c_str());
+    m_CMakeInstance->SetHomeOutputDirectory(m_WhereBuild.c_str());
+    m_CMakeInstance->SetStartOutputDirectory(m_WhereBuild.c_str());
+    m_CMakeInstance->SetGlobalGenerator(
+      m_CMakeInstance->CreateGlobalGenerator("NMake Makefiles"));
+    m_CMakeInstance->SetCMakeCommand(m_PathToExecutable.c_str());
+    m_CMakeInstance->LoadCache();
+    if(m_CMakeInstance->Configure() != 0)
+      {
+      cmSystemTools::Error(
+        "Error in configuration process, project files may be invalid");
+      }
+    // update the GUI with any new values in the caused by the
+    // generation process
+    this->LoadCacheFromDiskToGUI();
+    }
+
+  // path is up-to-date now
+  m_BuildPathChanged = false;
+
+
+  // put the cursor back
+  fl_cursor(FL_CURSOR_DEFAULT,FL_BLACK,FL_WHITE);
+  fl_message("Done !");
+
+}
+
+
+
+
+/**
+ * Load Cache from disk to GUI
+ */
+void
+CMakeSetupGUIImplementation
+::LoadCacheFromDiskToGUI( void )
+{
+  
+    
+  if( m_WhereBuild != "" )
+    { 
+    cmCacheManager *cachem = this->m_CMakeInstance->GetCacheManager();
+    cachem->LoadCache( m_WhereBuild.c_str() );
+    this->FillCacheGUIFromCacheManager();
+    }
+}
+   
+
+/**
+ * Save Cache from disk to GUI
+ */
+void
+CMakeSetupGUIImplementation
+::SaveCacheFromGUI( void )
+{
+  cmCacheManager *cachem = this->m_CMakeInstance->GetCacheManager();
+  this->FillCacheManagerFromCacheGUI();
+  if(m_WhereBuild != "")
+    {
+    cachem->SaveCache(m_WhereBuild.c_str());
+    }
+}
+
+
+/**
+ * Fill Cache GUI from cache manager
+ */
+void
+CMakeSetupGUIImplementation
+::FillCacheGUIFromCacheManager( void )
+{
+  cmCacheManager *cachem = this->m_CMakeInstance->GetCacheManager();
+  cmCacheManager::CacheIterator it = cachem->NewIterator();
+  size_t size = m_CacheEntriesList.GetItems().size();
+  bool reverseOrder = false;
+  // if there are already entries in the cache, then
+  // put the new ones in the top, so they show up first
+  if(size)
+    {
+    reverseOrder = true;
+    }
+
+  // all the current values are not new any more
+  std::set<fltk::PropertyItem*> items = m_CacheEntriesList.GetItems();
+  for(std::set<fltk::PropertyItem*>::iterator i = items.begin();
+      i != items.end(); ++i)
+    {
+    fltk::PropertyItem* item = *i;
+    item->m_NewValue = false;
+    }
+  // Prepare to add rows to the FLTK scroll/pack
+  propertyListPack->clear();
+  propertyListPack->begin();
+
+//    const cmCacheManager::CacheEntryMap &cache =
+//      cmCacheManager::GetInstance()->GetCacheMap();
+//    if(cache.size() == 0)
+//      {
+//      m_OKButton->deactivate();
+//      }
+//    else
+//      {
+//      m_OKButton->activate();
+//      }
+
+
+
+
+  for(cmCacheManager::CacheIterator i = cachem->NewIterator();
+      !i.IsAtEnd(); i.Next())
+    {
+    const char* key = i.GetName();
+    std::string value = i.GetValue();
+    bool advanced = i.GetPropertyAsBool("ADVANCED");
+    switch(i.GetType() )
+      {
+      case cmCacheManager::BOOL:
+        if(cmSystemTools::IsOn(value.c_str()))
+          {
+         m_CacheEntriesList.AddProperty(key,
+                                         "ON",
+                                         i.GetProperty("HELPSTRING"),
+                                         fltk::PropertyList::CHECKBOX,"",
+                                         reverseOrder);
+          }
+        else
+          {
+           m_CacheEntriesList.AddProperty(key,
+                                         "OFF",
+                                         i.GetProperty("HELPSTRING"),
+                                         fltk::PropertyList::CHECKBOX,"",
+                                         reverseOrder);
+          }
+        break;
+      case cmCacheManager::PATH:
+         m_CacheEntriesList.AddProperty(key, 
+                                       value.c_str(),
+                                       i.GetProperty("HELPSTRING"),
+                                       fltk::PropertyList::PATH,"",
+                                       reverseOrder);
+        break;
+      case cmCacheManager::FILEPATH:
+         m_CacheEntriesList.AddProperty(key, 
+                                       value.c_str(),
+                                       i.GetProperty("HELPSTRING"),
+                                       fltk::PropertyList::FILE,"",
+                                       reverseOrder);
+         break;
+      case cmCacheManager::STRING:
+        m_CacheEntriesList.AddProperty(key,
+                                       value.c_str(),
+                                       i.GetProperty("HELPSTRING"),
+                                       fltk::PropertyList::EDIT,"",
+                                       reverseOrder);
+        break;
+      case cmCacheManager::STATIC:
+      case cmCacheManager::INTERNAL:
+        m_CacheEntriesList.RemoveProperty(key);
+        break;
+      }
+    }
+
+  // Add the old entry to the end of the pack
+  for(std::set<fltk::PropertyItem*>::iterator i = items.begin();
+      i != items.end(); ++i)
+    {
+    fltk::PropertyItem* item = *i;
+    if( !(item->m_NewValue) )
+      {
+      new fltk::PropertyItemRow( item ); // GUI of the old property row
+      }
+    }
+
+  propertyListPack->end();
+  propertyListPack->init_sizes();
+  cacheValuesScroll->position( 0, 0 );
+
+  propertyListPack->redraw();
+
+  Fl::check();
+
+  this->UpdateData(false);
+
+}
+
+
+/**
+ * UpdateData
+ */
+void
+CMakeSetupGUIImplementation
+::UpdateData( bool option )
+{
+  dialogWindow->redraw();
+  Fl::check();
+}
+
+
+
+/**
+ * Fill cache manager from Cache GUI 
+ */
+void
+CMakeSetupGUIImplementation
+::FillCacheManagerFromCacheGUI( void )
+{
+  cmCacheManager *cachem = this->m_CMakeInstance->GetCacheManager();
+  cmCacheManager::CacheIterator it = cachem->NewIterator();
+  std::set<fltk::PropertyItem*> items = m_CacheEntriesList.GetItems();
+  for(std::set<fltk::PropertyItem*>::iterator i = items.begin();
+      i != items.end(); ++i)
+    {
+      fltk::PropertyItem* item = *i; 
+      if ( it.Find((const char*)item->m_propName.c_str()) )
+        {
+        it.SetValue(item->m_curValue.c_str());
+        }
+      if( item->m_Dirty )
+        {
+        m_CacheEntriesList.SetDirty();
+        }
+    }
+}
+
+
+
+
+/**
+ * Load Recent Directories
+ */
+void
+CMakeSetupGUIImplementation
+::LoadRecentDirectories( void )
+{
+  std::string home = getenv("HOME");
+  std::string filename = home + "/.cmakerc";
+  
+  std::ifstream input;
+  input.open(filename.c_str());
+  
+  if( input.fail() ) 
+  {
+    // probably the file doesn't exist
+    return;
+  }
+  
+  m_RecentBinaryDirectories.clear();
+  m_RecentSourceDirectories.clear();
+
+  std::string key;
+  std::string onedirectory;
+
+  while( !input.eof() )
+  {
+    input >> key;
+    
+    if( input.eof() ) break;
+
+    if( key == "MostRecentSource" )
+    {
+      input >> onedirectory;
+      m_WhereSource = onedirectory;
+      sourcePathTextInput->value( m_WhereSource.c_str() );
+    } else
+    if( key == "MostRecentBinary" )
+    {
+      input >> onedirectory;
+      m_WhereBuild = onedirectory;
+      binaryPathTextInput->value( m_WhereBuild.c_str() );
+      LoadCacheFromDiskToGUI();
+    } else
+    if( key == "Binary" )
+    {
+      input >> onedirectory;
+      // insert is only done if the directory doesn't exist
+      m_RecentBinaryDirectories.insert( onedirectory );
+      recentBinaryDirectoriesBrowser->add(
+                      (onedirectory.c_str()),
+                      (void*)(onedirectory.c_str()) );
+    } else
+    if( key == "Source" )
+    {
+      input >> onedirectory;
+      // insert is only done if the directory doesn't exist
+      m_RecentSourceDirectories.insert( onedirectory );
+      recentSourceDirectoriesBrowser->add(
+                      (onedirectory.c_str()),
+                      (void*)(onedirectory.c_str()) );
+    }
+
+  }
+
+  input.close();
+}
+
+
+
+/**
+ * Save Recent Directories
+ */
+void
+CMakeSetupGUIImplementation
+::SaveRecentDirectories( void )
+{
+  std::string home = getenv("HOME");
+
+  if( home.empty() )
+  {
+    return;
+  }
+  
+  std::string filename = home + "/.cmakerc";
+  
+  std::ofstream output;
+  output.open(filename.c_str());
+
+  output << "MostRecentBinary " << m_WhereBuild  << std::endl;
+  output << "MostRecentSource " << m_WhereSource << std::endl;
+
+  // Save Recent binary directories
+  std::set< std::string >::iterator bindir = 
+                m_RecentBinaryDirectories.begin();
+
+  while( bindir != m_RecentBinaryDirectories.end() )
+  {
+    output << "Binary " << *bindir << std::endl;
+    bindir++;
+  }
+
+
+  // Save Recent source directories
+  std::set< std::string >::iterator srcdir = 
+                m_RecentSourceDirectories.begin();
+
+  while( srcdir != m_RecentSourceDirectories.end() )
+  {
+    output << "Source " << *srcdir << std::endl;
+    srcdir++;
+  }
+
+}
+
+
+/**
+ * Show Recent Binary Directories
+ */
+void
+CMakeSetupGUIImplementation
+::ShowRecentBinaryDirectories( void )
+{
+  if( recentBinaryDirectoriesBrowser->size() )
+    {
+    recentBinaryDirectoriesBrowser->Fl_Widget::show();
+    }
+}
+
+
+/**
+ * Show Recent Source Directories
+ */
+void
+CMakeSetupGUIImplementation
+::ShowRecentSourceDirectories( void )
+{
+  if( recentSourceDirectoriesBrowser->size() )
+    {
+    recentSourceDirectoriesBrowser->Fl_Widget::show();
+    }
+}
+
+
+/**
+ * Select one Recent Binary Directory
+ */
+void
+CMakeSetupGUIImplementation
+::SelectOneRecentBinaryDirectory( void )
+{
+  const int selected = recentBinaryDirectoriesBrowser->value();
+  if( selected == 0 )
+  {
+    return;
+  }
+  
+  m_WhereBuild = static_cast<char *>(
+           recentBinaryDirectoriesBrowser->data( selected ));
+  binaryPathTextInput->value( m_WhereBuild.c_str() );
+  recentBinaryDirectoriesBrowser->Fl_Widget::hide();
+  m_CacheEntriesList.RemoveAll(); // remove data from other project
+  LoadCacheFromDiskToGUI();
+}
+
+
+/**
+ * Select one Recent Source Directory
+ */
+void
+CMakeSetupGUIImplementation
+::SelectOneRecentSourceDirectory( void )
+{
+  const int selected = recentSourceDirectoriesBrowser->value();
+  if( selected == 0 )
+  {
+    return;
+  }
+  m_WhereSource =  static_cast< char * >(
+          recentSourceDirectoriesBrowser->data( selected ));
+  sourcePathTextInput->value( m_WhereSource.c_str() );
+  recentSourceDirectoriesBrowser->Fl_Widget::hide();
+}
+
+
+
+/**
+ * Update List of Recent Directories
+ */
+void
+CMakeSetupGUIImplementation
+::UpdateListOfRecentDirectories( void )
+{
+
+  // Update Recent binary directories
+  // insert is only done if the directory doesn't exist
+  m_RecentBinaryDirectories.insert( m_WhereBuild );
+  
+  // Update Recent source directories
+  // insert is only done if the directory doesn't exist
+  m_RecentSourceDirectories.insert( m_WhereSource );
+
+}
+
+
+
+
+
+/**
+ * Clicked on Configure Button
+ */
+void
+CMakeSetupGUIImplementation
+::ClickOnConfigure( void )
+{
+  this->RunCMake(false);
+}
+
+
+
+
+/**
+ * Clicked on OK Button
+ */
+void
+CMakeSetupGUIImplementation
+::ClickOnOK( void )
+{
+  m_CacheEntriesList.ClearDirty();
+  this->RunCMake(true);
+  this->Close();
+}
+
+
+
+
+/**
+ * Clicked on Cancel Button
+ */
+void
+CMakeSetupGUIImplementation
+::ClickOnCancel( void )
+{
+  if(m_CacheEntriesList.IsDirty())
+    {
+    int userWantsExitEvenThoughOptionsHaveChanged = 
+      fl_ask("You have changed options but not rebuilt, \n"
+                  "are you sure you want to exit?");
+    if( userWantsExitEvenThoughOptionsHaveChanged )
+      {
+      this->Close();
+      }
+    }
+  else
+    {
+    this->Close();
+    }
+
+}
+
+
+
+
+