#else
#include <unistd.h>
#include <algo.h>
+#include <sys/utsname.h>
#endif
#ifdef WNT
* Creates HTML-wrapped title text
*/
// ================================================================
-QString makeTitle( const QString& text, const QString& separator = " ", bool fl = true )
+static QString makeTitle( const QString& text, const QString& separator = " ", bool fl = true )
{
QStringList words = QStringList::split( separator, text );
if ( fl ) {
.arg( __IW_VERSION_MINOR__ ) \
.arg( __IW_VERSION_PATCH__ ) );
QLabel* copyright = new QLabel( this, "copyright" );
- copyright->setText( "<b>Copyright</b> © 2004-2008 CEA" );
+ copyright->setText( "<b>Copyright</b> © 2007-2008 CEA/DEN, EDF R&D, OPEN CASCADE<br><br>"
+ "<b>Copyright</b> © 2003-2007 OPEN CASCADE,<br>EADS/CCR, LIP6, CEA/DEN, CEDRAT, EDF R&D,<br>LEG, PRINCIPIA R&D, BUREAU VERITAS");
QFont font = title->font();
font.setPointSize( (int)( font.pointSize() * 1.8 ) );
title->setFont( font );
QFontMetrics fm( title->font() );
int width = (int)( fm.width( tlt ) * 1.5 );
title->setMinimumWidth( width );
- setMaximumSize( minimumSize() );
+// setMaximumSize( minimumSize() );
}
void mousePressEvent( QMouseEvent* )
{
// ================================================================
SALOME_InstallWizard::SALOME_InstallWizard(const QString& aXmlFileName,
const QString& aTargetDir,
- const QString& aTmpDir)
+ const QString& aTmpDir,
+ const bool aForceSrc,
+ const bool aSingleDir)
: InstallWizard( qApp->desktop(), "SALOME_InstallWizard", false, 0 ),
helpWindow( NULL ),
moreMode( false ),
xmlFileName = aXmlFileName;
myTargetPath = aTargetDir;
myTmpPath = aTmpDir;
+ forceSrc = aForceSrc;
+ singleDir = aSingleDir;
stateChanged = true;
binPath = QDir::currentDirPath() + "/Products/BINARIES";
srcPath = QDir::currentDirPath() + "/Products/SOURCES";
+ oneProdDirName = "PRODUCTS";
- singleBinPlts << "Debian4.0"
- << "Debian3.1"
- << "Mandriva2006.0"
- << "Mandriva2007.0"
- << "Mandriva2008.0"
- << "Mandriva2006.0_64"
- << "Mandriva2008.0_64";
- commonPlatform = "Debian3.1";
+ commonPlatform = "Debian 3.1";
//
// get XML filename and current platform
//
// ... get current platform
- curPlatform = currentPlatform();
+ curPlatform = currentPlatform().join(" ");
// cout << "curOS = " << curPlatform << endl;
// curPlatform = "";
+ refPlatform = "";
// ... check XML and platform definition
getXmlAndPlatform();
addLogo( pixmap( pxLogo ) );
// set defaults
- setVersion( "4.1.1" );
+ setVersion( "5.1.0" );
setCaption( tr( "SALOME %1" ).arg( myVersion ) );
- setCopyright( tr( "Copyright (C) 2008 CEA" ) );
- setLicense( tr( "All rights reserved." ) );
+ setCopyright( tr( "<h5>Copyright © 2007-2008 CEA/DEN, EDF R&D, OPEN CASCADE<br></h5>"
+ "<h5>Copyright © 2003-2007 OPEN CASCADE,<br>EADS/CCR, LIP6, CEA/DEN, CEDRAT, EDF R&D,<br>LEG, PRINCIPIA R&D, BUREAU VERITAS</h5>" ));
+ setLicense( tr( "<h5>GNU LGPL</h5>" ) );
___MESSAGE___( "Configuration file : " << xmlFileName.latin1() );
___MESSAGE___( "Target directory : " << myTargetPath.latin1() );
// create instance of class for starting shell script to get available disk space
diskSpaceProc = new QProcess( this, "procDiskSpace" );
- connect( diskSpaceProc, SIGNAL( processExited() ), this, SLOT( updateAvailableSpace() ) );
-
// create instance of class for starting shell install script
shellProcess = new QProcess( this, "shellProcess" );
-
+ // create instance of class for starting shell script to modify SALOME *.la files
+ modifyLaProc = new QProcess( this, "modifyLaProc" );
// create instance of class for starting shell script to check Fortran libraries
checkFLibProc = new QProcess( this, "checkFLibProc" );
- connect(checkFLibProc, SIGNAL( processExited() ), this, SLOT( checkFLibResult() ) );
// create introduction page
setupIntroPage();
connect( this, SIGNAL( helpClicked() ), this, SLOT( helpClicked() ) );
connect( this, SIGNAL( aboutClicked() ), this, SLOT( onAbout() ) );
- // catch signals from launched script
+ // catch signals from launched diskSpaceProc
+ connect( diskSpaceProc, SIGNAL( processExited() ), this, SLOT( updateAvailableSpace() ) );
+ // catch signals from launched shellProcess
connect(shellProcess, SIGNAL( readyReadStdout() ), this, SLOT( readFromStdout() ) );
connect(shellProcess, SIGNAL( readyReadStderr() ), this, SLOT( readFromStderr() ) );
connect(shellProcess, SIGNAL( processExited() ), this, SLOT( productInstalled() ) );
connect(shellProcess, SIGNAL( wroteToStdin() ), this, SLOT( wroteToStdin() ) );
+ // catch signals from launched modifyLaProc
+ connect(modifyLaProc, SIGNAL( readyReadStdout() ), this, SLOT( readFromStdout() ) );
+ connect(modifyLaProc, SIGNAL( readyReadStderr() ), this, SLOT( readFromStderr() ) );
+ connect(modifyLaProc, SIGNAL( processExited() ), this, SLOT( checkModifyLaResult() ) );
+ // catch signals from launched checkFLibProc
+ connect(checkFLibProc, SIGNAL( processExited() ), this, SLOT( checkFLibResult() ) );
// create validation thread
myThread = new ProcessThread( this );
QString SALOME_InstallWizard::getBasePlatform()
{
QString aBasePlt = "";
- if ( singleBinPlts.contains(curPlatform) )
+ if ( platformsMap.find( curPlatform ) != platformsMap.end() )
aBasePlt = curPlatform;
else
aBasePlt = commonPlatform;
* Tries to determine the current user's operating system
*/
// ================================================================
-QString SALOME_InstallWizard::currentPlatform()
+QStringList SALOME_InstallWizard::currentPlatform()
{
// file parsing
- QString curOS = "";
+ QString platName, platVersion, platArch;
QString osFileName = "/etc/issue";
if ( QFile::exists( osFileName ) ) {
QFile file( osFileName );
QTextStream stream( &file );
QString str = stream.readLine();
file.close();
- // line parsing
- QString pltName = "", platVersion = "", platBit = "";
- QRegExp rx( "(.*)[L|l]inux.*release\\s+([\\d.]*)" );
-// str = "Debian GNU/Linux 3.1 \n \l";
-// str = "Red Hat Enterprise Linux WS release 4 (Nahant)";
-// str = "Mandriva Linux release 2006.0 (Official) for x86_64";
- int pos = rx.search( str );
- if ( pos == -1 ) {// Debian case
- rx = QRegExp( "(.*)GNU/Linux\\s+([\\d.]*)" );
- pos = rx.search( str );
+ // parse line
+ QRegExp regvar = QRegExp( "(.*)\\s+[^\\s]*[R|r]elease[^\\s]*\\s+([\\d.]*)" );
+ int pos = regvar.search( str );
+ if ( pos == -1 ) {
+ regvar = QRegExp( "(.*)\\s+[^\\s]*[L|l][I|i][N|n][U|u][X|x][^\\s]*(.*)\\s+([\\d.]*)\\s+" );
+ pos = regvar.search( str );
}
- if ( pos > -1 ) {
- pltName = rx.cap( 1 );
- platVersion = rx.cap( 2 );
- rx = QRegExp( "x86_64" );
- pos = rx.search( str );
- if ( pos > -1 )
- platBit = "_64";
- curOS = pltName + platVersion + platBit;
+ if ( pos >= 0 ) {
+ QStringList name;
+ for ( int i = 1; i < regvar.numCaptures(); i++ )
+ name.append( regvar.cap( i ) );
+
+ // retrieve platform name
+ platName = QStringList::split( " ", name.join( " " ) ).join( " " );
+ platName = platName.replace( "Linux", "" ).replace( "linux", "" ).replace( "LINUX", "" ).stripWhiteSpace();
+ platName = platName.replace( "Welcome to", "" ).stripWhiteSpace();
+ platName = QStringList::split( " ", platName ).join( " " );
+ // retrieve platform version number
+ platVersion = regvar.cap( regvar.numCaptures() );
+ // retrieve platform
+ utsname uname_data;
+ uname( &uname_data );
+ if ( QString( uname_data.machine ) == "x86_64" )
+ platArch = "64bit";
}
}
}
- // return curOS.remove( " " );
- QString str( " " );
- int index = 0;
- while ( (index = curOS.find( str, index, true)) != -1 )
- curOS.remove( index, str.length() );
- return curOS;
+ QStringList vals;
+ if ( !platName.isEmpty() ) vals.append( platName );
+ if ( !platVersion.isEmpty() ) vals.append( platVersion );
+ if ( !platArch.isEmpty() ) vals.append( platArch );
+ return vals;
+}
+// ================================================================
+/*!
+ * SALOME_InstallWizard::getPlatformBinPath
+ * Get platform binaries path
+ */
+// ================================================================
+QString SALOME_InstallWizard::getPlatformBinPath( const QString& plt ) const
+{
+ return QDir::cleanDirPath( getBinPath() + "/" + QStringList::split( " ", plt ).join( "_" ) );
}
+
// ================================================================
/*!
* SALOME_InstallWizard::getXmlMap
* corresponding XML files.
*/
// ================================================================
-MapXmlFiles SALOME_InstallWizard::getXmlMap( const QString& xmlFileName )
+MapXmlFiles SALOME_InstallWizard::getXmlMap( const QString& aXmlFileName )
{
MapXmlFiles xmlMap;
QStringList xmlList;
- if ( xmlFileName )
- xmlList.append( xmlFileName );
+ if ( !aXmlFileName.isEmpty() )
+ xmlList.append( aXmlFileName );
else {
QDir dir( QDir::currentDirPath() );
xmlList = dir.entryList( "*.xml", QDir::Files | QDir::Readable );
}
-// cout << xmlList.join(",") << endl;
+ if ( xmlList.remove( "config.xml" ) )
+ xmlList.append( "config.xml" );
// XML files parsing
QFile file;
QDomDocument doc( "xml_doc" );
platforms = elem.attribute( "platforms" ).stripWhiteSpace();
QStringList platList = QStringList::split( ",", platforms );
for ( uint j = 0; j < platList.count(); j++ ) {
- if ( !platList[j].isEmpty() && xmlMap.find( platList[j] ) == xmlMap.end() )
+ QString platform = platList[j].stripWhiteSpace();
+ if ( !platform.isEmpty() && xmlMap.find( platform ) == xmlMap.end() )
xmlMap[ platList[j] ] = xmlList[i];
}
-// if ( !curPlatform.isEmpty() && xmlMap.find( curPlatform ) != xmlMap.end() )
-// return xmlMap;
}
}
}
void SALOME_InstallWizard::getXmlAndPlatform()
{
MapXmlFiles xmlMap;
- if ( xmlFileName.isNull() ) {
+ if ( xmlFileName.isEmpty() ) {
xmlMap = getXmlMap();
if ( !curPlatform.isEmpty() ) {
// try to get XML file for current platform
if ( xmlMap.find( curPlatform ) != xmlMap.end() ) {
- xmlFileName = xmlMap[ getBasePlatform() ];
- QFileInfo fibp( QDir::cleanDirPath( getBinPath() + "/" + getBasePlatform() ) );
+ xmlFileName = xmlMap[ curPlatform ];
+ QFileInfo fibp( getPlatformBinPath( curPlatform ) );
if ( !fibp.isDir() ) {
warnMsg = tr( "Binaries are absent for current platform" );
}
else {
// get all supported platforms
platformsMap = xmlMap;
- warnMsg = tr( "Install Wizard can't define your Linux platform" );
+ warnMsg = tr( "Installation Wizard can't identify target Linux platform" );
}
}
else {
platformsMap.insert( it.key(), it.data(), true );
warnMsg = tr( "The given configuration file doesn't support your Linux platform" );
}
+ else {
+ platformsMap = xmlMap;
+ }
}
else {
// get all supported platforms
MapXmlFiles::Iterator it;
for ( it = xmlMap.begin(); it != xmlMap.end(); ++it )
platformsMap.insert( it.key(), it.data(), true );
- warnMsg = tr( "Install Wizard can't define your Linux platform" );
+ warnMsg = tr( "Installation Wizard can't define your Linux platform" );
}
}
}
if ( installType == Binaries ) { // 'Binary' installation type
// check binaries directory
QFileInfo fib( QDir::cleanDirPath( getBinPath() ) );
- if ( !fib.exists() ) {
+ if ( !fib.isDir() ) {
QMessageBox::warning( this,
tr( "Warning" ),
tr( "The directory %1 doesn't exist.\n"
}
else {
// Supported platform case
- QString aPlatform = curPlatform;
- if ( curPlatform != getBasePlatform() ) {
- refPlatform = getBasePlatform();
- xmlFileName = platformsMap[ refPlatform ];
- aPlatform = getPlatform();
- }
- QFileInfo fibp( QDir::cleanDirPath( getBinPath() + "/" + aPlatform ) );
+ QFileInfo fibp( getPlatformBinPath( curPlatform ) );
if ( !fibp.isDir() ) {
warnLab->setText( tr( "Binaries are absent for current platform." ) );
this->setAppropriate( platformsPage, true );
// check sources directory
QFileInfo fis( QDir::cleanDirPath( getSrcPath() ) );
- if ( !fis.exists() )
+ if ( !fis.isDir() )
if ( QMessageBox::warning( this,
tr( "Warning" ),
tr( "The directory %1 doesn't exist.\n"
else { // 'Source' or 'Compile' installation type
// check sources directory
QFileInfo fis( QDir::cleanDirPath( getSrcPath() ) );
- if ( !fis.exists() ) {
+ if ( !fis.isDir() ) {
QMessageBox::warning( this,
tr( "Warning" ),
tr( "The directory %1 doesn't exist.\n"
QMessageBox::NoButton );
return false;
}
+ else if ( !QDir( fis.filePath(), "*.tar.gz" ).count() ) {
+ QMessageBox::warning( this,
+ tr( "Warning" ),
+ tr( "The directory %1 doesn't contain source archives.\n" ).arg( fis.absFilePath() ),
+ QMessageBox::Ok,
+ QMessageBox::NoButton,
+ QMessageBox::NoButton );
+ return false;
+ }
if ( platformsMap.find( curPlatform ) == platformsMap.end() ) {
QString aMsg = warnMsg + ".";
if ( installType == Compile )
QMessageBox::NoButton );
return false;
}
+ else if ( installType == Binaries ) {
+ QString aPlatform = platBtnGrp->selected()->name();
+ QFileInfo fib( getPlatformBinPath( aPlatform ) );
+ if ( !fib.isDir() ) {
+ QMessageBox::warning( this,
+ tr( "Warning" ),
+ tr( "The directory %1 doesn't exist.\n"
+ "This directory must contains binary archives.\n" ).arg( fib.absFilePath() ),
+ QMessageBox::Ok,
+ QMessageBox::NoButton,
+ QMessageBox::NoButton );
+ return false;
+ }
+ else if ( QDir( fib.filePath(), "*.tar.gz" ).count() == 0 ) {
+ QMessageBox::warning( this,
+ tr( "Warning" ),
+ tr( "The directory %1 doesn't contain binary archives.\n" ).arg( fib.absFilePath() ),
+ QMessageBox::Ok,
+ QMessageBox::NoButton,
+ QMessageBox::NoButton );
+ return false;
+ }
+ }
}
else if ( aPage == dirPage ) {
return false;
}
QFileInfo fi( QDir::cleanDirPath( targetDir ) );
- if ( !fi.exists() ) {
+ if ( !fi.isDir() ) {
bool toCreate =
QMessageBox::warning( this,
tr( "Warning" ),
availableSize->setText( diskSpaceProc->readLineStdout() + " KB");
}
// ================================================================
+/*!
+ * SALOME_InstallWizard::runModifyLaFiles
+ * Run the modification of SALOME *.la files
+ */
+// ================================================================
+void SALOME_InstallWizard::runModifyLaFiles()
+{
+ modifyLaProc->clearArguments();
+ // ... update status label
+ statusLab->setText( tr( "Modification of *.la files of SALOME modules..." ) );
+ // set process arguments
+ modifyLaProc->setWorkingDirectory( QDir::cleanDirPath( QFileInfo( "./config_files/" ).absFilePath() ) );
+ modifyLaProc->addArgument( "modifyLaFiles.sh" );
+ modifyLaProc->addArgument( "modify_la_files" );
+ modifyLaProc->addArgument( QDir::cleanDirPath( QFileInfo( targetFolder->text().stripWhiteSpace() ).absFilePath() ) );
+ // ... run script
+ if ( !modifyLaProc->start() )
+ ___MESSAGE___( "Error: process could not start!" );
+}
+// ================================================================
+/*!
+ * SALOME_InstallWizard::checkModifyLaResult
+ * Slot to take result of modification SALOME *.la files
+ */
+// ================================================================
+void SALOME_InstallWizard::checkModifyLaResult()
+{
+ if ( modifyLaProc->normalExit() && modifyLaProc->exitStatus() == 1 )
+ runCheckFLib();
+ else {
+ // abort of the current installation
+ abort();
+ statusLab->setText( tr( "Installation has been aborted" ) );
+ QMessageBox::critical( this,
+ tr( "Error" ),
+ tr( "Modification of *.la SALOME files has not been completed."),
+ QMessageBox::Ok,
+ QMessageBox::NoButton,
+ QMessageBox::NoButton );
+ // enable <Next> button
+ setNextEnabled( true );
+ nextButton()->setText( tr( "&Start" ) );
+ setAboutInfo( nextButton(), tr( "Start installation process" ) );
+ // reconnect Next button - to use it as Start button
+ disconnect( this, SIGNAL( nextClicked() ), this, SLOT( next() ) );
+ disconnect( this, SIGNAL( nextClicked() ), this, SLOT( onStart() ) );
+ connect( this, SIGNAL( nextClicked() ), this, SLOT( onStart() ) );
+ // enable <Back> button
+ setBackEnabled( true );
+ }
+}
+// ================================================================
+/*!
+ * SALOME_InstallWizard::runCheckFLib
+ * Run the Fortran libraries checking
+ */
+// ================================================================
+void SALOME_InstallWizard::runCheckFLib()
+{
+ // Check Fortran libraries
+ checkFLibProc->clearArguments();
+ // ... update status label
+ statusLab->setText( tr( "Check Fortran libraries..." ) );
+ // ... search "not found" libraries
+ checkFLibProc->setWorkingDirectory( QDir::cleanDirPath( QFileInfo( "./config_files/" ).absFilePath() ) );
+ checkFLibProc->addArgument( "checkFortran.sh" );
+ checkFLibProc->addArgument( "find_libraries" );
+ checkFLibProc->addArgument( QDir::cleanDirPath( QFileInfo( targetFolder->text().stripWhiteSpace() ).absFilePath() ) );
+ // ... run script
+ if ( !checkFLibProc->start() )
+ ___MESSAGE___( "Error: process could not start!" );
+}
+// ================================================================
/*!
* SALOME_InstallWizard::checkFLibResult
* Slot to take result of Fortran libraries checking
return;
// get all prerequisites
QStringList dependOn = productsMap[ item ].getDependancies();
- // install MED without GUI case
- if ( installGuiBtn->state() != QButton::On && item->text(0) == "MED" ) {
+ // install SALOME without GUI case
+ if ( installGuiBtn->state() != QButton::On &&
+ woGuiModules.find( item->text(0) ) != woGuiModules.end() &&
+ woGuiModules[item->text(0)] == True ) {
dependOn.remove( "GUI" );
}
// setting prerequisites
itProd.key()->setOn( true );
itProd.key()->setEnabled( false );
}
+ break;
}
}
}
for ( itProd = productsMap.begin(); itProd != productsMap.end(); ++itProd ) {
if ( itProd.data().getType() == productsMap[ item ].getType() ) {
QStringList dependOn = itProd.data().getDependancies();
- // install MED without GUI case
- if ( installGuiBtn->state() != QButton::On &&
- itProd.data().getName() == "MED" &&
- itemName != "KERNEL" ) {
- continue;
- }
for ( int i = 0; i < (int)dependOn.count(); i++ ) {
if ( dependOn[ i ] == itemName ) {
if ( itProd.key()->isOn() ) {
for ( int k = 0; k < (int)prereqsList.count(); k++ ) {
if ( prereqsList[ k ] == itProd1.data().getName() ) {
nbDependents++;
+ break;
}
}
}
itProd1.key()->setOn( false );
}
}
+ break;
}
}
}
progressView->setStatus( prodProc, Processing );
progressView->ensureVisible( prodProc );
- QCheckListItem* item;
+ QCheckListItem* item = 0;
// fill in script parameters
shellProcess->clearArguments();
// ... script name
shellProcess->addArgument( extraProducts[ prodProc ] );
// ... get folder with binaries
- QString binDir = QDir::cleanDirPath( getBinPath() );
QString OS = getPlatform();
- if ( refPlatform.isEmpty() && singleBinPlts.contains(curPlatform) == 0 )
+ if ( refPlatform.isEmpty() && platformsMap.find( curPlatform ) == platformsMap.end() )
OS = commonPlatform;
- binDir += "/" + OS;
+ QString binDir = getPlatformBinPath( OS );
// ... temp folder
QString tmpFolder = QDir::cleanDirPath( tempFolder->text().stripWhiteSpace() ) + TEMPDIRNAME;
//if( !tempFolder->isEnabled() )
shellProcess->addArgument( "FALSE" );
// ... binaries directory
shellProcess->addArgument( binDir );
- // ... install MED with GUI or not?
- if ( prodProc == "MED" ) {
- if ( installGuiBtn->state() != QButton::On && prodProc == "MED" )
- shellProcess->addArgument( "FALSE" );
- else
+ // ... install SALOME with GUI or not?
+ if ( woGuiModules.find( prodProc ) != woGuiModules.end() )
+ ( installGuiBtn->state() != QButton::On && woGuiModules[ prodProc ] == True ) ?
+ shellProcess->addArgument( "FALSE" ) :
shellProcess->addArgument( "TRUE" );
- }
// ... single installation directory for SALOME modules, if this option was selected
if ( oneModDirBtn->isChecked() ) {
MapProducts::Iterator mapIter;
for ( mapIter = productsMap.begin(); mapIter != productsMap.end(); ++mapIter )
- if ( mapIter.data().getName() == prodProc && mapIter.data().getType() == "component" )
- shellProcess->addArgument( "SALOME" );
+ if ( mapIter.data().getName() == prodProc && mapIter.data().getType() == "component" ) {
+ shellProcess->addArgument( "TRUE" );
+ break;
+ }
}
// ... single installation directory for prerequisites, if this option was selected
if ( oneProdDirBtn->isChecked() ) {
if ( prodProc == "DebianLibsForSalome" )
- shellProcess->addArgument( "PRODUCTS" );
+ shellProcess->addArgument( oneProdDirName );
else {
MapProducts::Iterator mapIter;
for ( mapIter = productsMap.begin(); mapIter != productsMap.end(); ++mapIter )
- if ( mapIter.data().getName() == prodProc && mapIter.data().getType() == "prerequisite" )
- shellProcess->addArgument( "PRODUCTS" );
+ if ( mapIter.data().getName() == prodProc && mapIter.data().getType() == "prerequisite" ) {
+ shellProcess->addArgument( oneProdDirName );
+ break;
+ }
}
}
}
}
}
-
+
if ( installType == Binaries ) {
- // Check Fortran libraries
- // ... update status label
- statusLab->setText( tr( "Check Fortran libraries..." ) );
- // ... search "not found" libraries
- checkFLibProc->setWorkingDirectory( QDir::cleanDirPath( QFileInfo( "./config_files/" ).absFilePath() ) );
- checkFLibProc->addArgument( "checkFortran.sh" );
- checkFLibProc->addArgument( "find_libraries" );
- checkFLibProc->addArgument( QDir::cleanDirPath( QFileInfo( targetFolder->text().stripWhiteSpace() ).absFilePath() ) );
- // ... run script
- if ( !checkFLibProc->start() ) {
- ___MESSAGE___( "Error: process could not start!" );
- }
+ if ( oneModDirBtn->isChecked() )
+ runModifyLaFiles();
+ else
+ runCheckFLib();
}
- else
+ else {
// Update GUI and check installation errors
completeInstallation();
+ }
}
// ================================================================
}
else {
QString itemName = itProd.data().getName();
- if ( itemName != "KERNEL" && itemName != "MED" &&
- itemName != "SAMPLES" && itemName != "DOCUMENTATION" ) {
+ if ( woGuiModules.find( itemName ) == woGuiModules.end() ||
+ woGuiModules[ itemName ] == False ) {
itProd.key()->setOn( false );
itProd.key()->setEnabled( false );
}
if ( aPage == typePage ) {
// installation type page
if ( buttonGrp->id( buttonGrp->selected() ) == -1 )
- binBtn->animateClick(); // set default installation type
+ // set default installation type
+ forceSrc ? srcCompileBtn->animateClick() : binBtn->animateClick();
+ else
+ buttonGrp->selected()->animateClick();
}
else if ( aPage == platformsPage ) {
// installation platforms page
QString plat = it.key();
QRadioButton* rb = ( (QRadioButton*) platBtnGrp->child( plat ) );
if ( installType == Binaries ) {
- QFileInfo fib( QDir::cleanDirPath( getBinPath() + "/" + plat ) );
- rb->setEnabled( fib.exists() );
+ QFileInfo fib( getPlatformBinPath( plat ) );
+ rb->setEnabled( true/*fib.isDir()*/ );
if ( platBtnGrp->id( platBtnGrp->selected() ) == -1 && plat == getBasePlatform() )
rb->animateClick();
}
- else {
- QFileInfo fis( QDir::cleanDirPath( getSrcPath() ) );
- rb->setEnabled( fis.exists() );
- }
- rb->setChecked( rb->isChecked() && rb->isEnabled() );
+// rb->setChecked( rb->isChecked() && rb->isEnabled() );
+ if ( rb->isChecked() && rb->isEnabled() )
+ rb->animateClick();
}
setNextEnabled( platformsPage, platBtnGrp->id( platBtnGrp->selected() ) != -1 );
}
if ( tempFolder->text().isEmpty() )
parser->setTempDir( tempFolder );
parser->readXmlFile( xmlFileName );
+ // create a map of SALOME modules names, that can support installation without GUI mode
+ if ( woGuiModules.isEmpty() ) {
+ MapProducts::Iterator mapIter;
+ for ( mapIter = productsMap.begin(); mapIter != productsMap.end(); mapIter++ ) {
+ Dependancies dep = mapIter.data();
+ if ( dep.getType() == "component" && dep.supportWoGuiMode() != NotDefined )
+ woGuiModules[ dep.getName() ] = dep.supportWoGuiMode();
+ }
+ }
+
// update required size for each product
updateSizeColumn();
// take into account command line parameters
removeSrcBtn->setEnabled( installType == Compile );
oneModDirBtn->setEnabled( installType == Binaries /*|| installType == Compile*/ );
oneProdDirBtn->setEnabled( installType == Binaries || installType == Compile );
+ refPlatform = "";
+ xmlFileName = getXmlFile( curPlatform );
}
else if ( aPage == platformsPage ) {
refPlatform = platBtnGrp->find( rbIndex )->name();
- xmlFileName = platformsMap[ refPlatform ];
-// cout << xmlFileName << endl;
+ xmlFileName = getXmlFile( refPlatform );
setNextEnabled( platformsPage, true );
}
if ( prevType != installType ||
( indexOf( platformsPage ) != -1 ? prevPlat != getPlatform() : false ) ) {
stateChanged = true;
- oneModDirBtn->setChecked( false );
+ oneModDirBtn->setChecked( installType == Binaries && singleDir );
oneProdDirBtn->setChecked( false );
}
}
if ( nextButton()->text() == tr( "&Stop" ) ) {
statusLab->setText( tr( "Aborting installation..." ) );
shellProcess->kill();
+ modifyLaProc->kill();
while( shellProcess->isRunning() );
statusLab->setText( tr( "Installation has been aborted by user" ) );
return;
void SALOME_InstallWizard::onCancel()
{
shellProcess->kill();
+ modifyLaProc->kill();
+ checkFLibProc->kill();
reject();
}
// ================================================================
void SALOME_InstallWizard::readFromStdout( )
{
___MESSAGE___( "Something was sent to stdout" );
- while ( shellProcess->canReadLineStdout() ) {
- installInfo->append( QString( shellProcess->readLineStdout() ) );
+ QProcess* theProcess = ( QProcess* )sender();
+ while ( theProcess->canReadLineStdout() ) {
+ installInfo->append( QString( theProcess->readLineStdout() ) );
installInfo->scrollToBottom();
}
- QString str( shellProcess->readStdout() );
+ QString str( theProcess->readStdout() );
if ( !str.isEmpty() ) {
installInfo->append( str );
installInfo->scrollToBottom();
void SALOME_InstallWizard::readFromStderr( )
{
___MESSAGE___( "Something was sent to stderr" );
- while ( shellProcess->canReadLineStderr() ) {
- installInfo->append( OUTLINE_TEXT( QString( shellProcess->readLineStderr() ) ) );
+ QProcess* theProcess = ( QProcess* )sender();
+ while ( theProcess->canReadLineStderr() ) {
+ installInfo->append( OUTLINE_TEXT( QString( theProcess->readLineStderr() ) ) );
installInfo->scrollToBottom();
hasErrors = true;
}
- QString str( shellProcess->readStderr() );
+ QString str( theProcess->readStderr() );
if ( !str.isEmpty() ) {
installInfo->append( OUTLINE_TEXT( str ) );
installInfo->scrollToBottom();