Projects/ds4clonerestore/ds4clonerestore/src/restore.cpp

00001 /******************************************************
00002 * DS4 Clone-Restore
00003 *
00004 * DS4 Laser Technology srl
00005 *
00006 * author: Carsana Francesco <francescocarsana@ds4.it>
00007 *******************************************************/
00008 
00009 
00010 #include "restore.h"
00011 
00012 
00013 Restore::Restore( QWidget* parent, const char* name, WFlags fl )
00014         : restoreDlg( parent, name, fl )
00015 {
00016     mainWin = parent;
00017     dir = new QDir(); // oggetto per la navigazione nelle directory
00018     partitionTableFile = new QFile(); // oggetto per accedere al file della tabella delle partizioni
00019 
00020     proc = new QProcess(); // oggetto per lanciare un comando esterno
00021 
00022     // finestra per visualizzare l'output dei comandi
00023     output = new RestoreOutput(this,"Restore Output",TRUE);
00024     
00025     strcpy(pathRev,RevPathMount().ascii()); // leggo il percorso di mount del Rev
00026     strcpy(deviceHDDestination,HDDevice().ascii()); // leggo il device dell'hard disk di destinazione
00027     strcpy(swapPartition,SystemSwapPartition().ascii()); // leggo la partizione di swap di sistema
00028     
00029     strcpy(pathServer,ServerPathMount().ascii()); // leggo il percorso di mount della directory condivisa
00030     strcpy(addressServer,ServerAddress().ascii()); // leggo l'indirizzo del server e la directory condivisa
00031 
00032     // collegamento per gestire l'output
00033     connect( proc, SIGNAL(readyReadStdout()), this, SLOT(readFromStdout()) );
00034     connect( proc, SIGNAL(readyReadStderr()), this, SLOT(readFromStderr()) );
00035 }
00036 
00037 
00038 Restore::~Restore()
00039 {
00040     delete dir;
00041     dir = NULL;
00042     delete partitionTableFile;
00043     partitionTableFile = NULL;
00044     delete proc;
00045     proc = NULL;
00046     delete output;
00047     output = NULL;
00048 }
00049 
00050 
00051 void Restore::Init(bool *mountedRev, bool *mountedServer)
00052 {
00053     revMounted = mountedRev;
00054     foundedRev = FALSE;
00055     if (*revMounted == TRUE) // se il Rev e' montato
00056     {
00057         radRev->setEnabled(TRUE);
00058         ledRevStatus->setColor(Qt::green); // led verde
00059         
00060         if (radRev->isChecked()) // se e' selezionato il radio button Rev
00061         {
00062             // leggo i nomi delle directory delle macchine sul Rev, nome directory = numero seriale
00063             dir->cd(pathRev,TRUE); // punto sul rev
00064             machineList = dir->entryList(QDir::Dirs,QDir::Name);
00065     
00066             cmbSerial->clear(); // cancello le entry della ComboBox
00067     
00068             // riempio il ComboBox relativo ai numeri seriali
00069             for ( QStringList::Iterator it = machineList.begin(); it != machineList.end(); ++it )
00070             {
00071                 if ((*it != ".") && (*it != "..") && (*it != "lost+found")) // escludo dai seriali le directory . e ..
00072                     cmbSerial->insertItem(*it);
00073             }
00074             
00075             if (cmbSerial->count() > 0) // se c'e' almeno un elemento nella combobox
00076                 foundedRev = TRUE;
00077             else
00078                 foundedRev = FALSE;
00079             
00080             this->cmbSerial_activated(cmbSerial->currentText()); // aggiorno il ComboBox dei numeri seriali
00081         }
00082     }
00083     else // se il Rev non e' montato
00084     {
00085         radRev->setEnabled(FALSE);
00086         ledRevStatus->setColor(Qt::red); // led rosso
00087         radServer->setChecked(TRUE); // restore da Server
00088     }
00089     
00090     serverMounted = mountedServer;
00091     foundedServer = FALSE;
00092     if (*serverMounted == TRUE) // se e' montata la directory condivisa abilito il radio button del server
00093     {
00094         radServer->setEnabled(TRUE);
00095         ledServerStatus->setColor(Qt::green); // led verde
00096         
00097         if (radServer->isChecked()) // se e' selezionato il radio button Server
00098         {
00099             // leggo i nomi delle directory delle macchine, nome directory = numero seriale
00100             dir->cd(pathServer,TRUE); // punto sulla directory condivisa
00101             machineList = dir->entryList(QDir::Dirs,QDir::Name);
00102     
00103             cmbSerial->clear(); // cancello le entry della ComboBox
00104     
00105             // riempio il ComboBox relativo ai numeri seriali
00106             for ( QStringList::Iterator it = machineList.begin(); it != machineList.end(); ++it )
00107             {
00108                 if ((*it != ".") && (*it != "..") && (*it != "lost+found")) // escludo dai seriali le directory . e ..
00109                     cmbSerial->insertItem(*it);
00110             }
00111             
00112             if (cmbSerial->count() > 0) // se c'e' almeno un elemento nella combobox
00113                 foundedServer = TRUE;
00114             else
00115                 foundedServer = FALSE;
00116             
00117             this->cmbSerial_activated(cmbSerial->currentText()); // aggiorno il ComboBox dei numeri seriali
00118         }
00119     }
00120     else // altrimenti lo disabilito
00121     {
00122         radServer->setEnabled(FALSE);
00123         ledServerStatus->setColor(Qt::red); // led rosso
00124         radRev->setChecked(TRUE); // restore da Rev
00125     }
00126     
00127     // se non c'e' almeno un'immagine
00128     if ((!foundedRev) && (!foundedServer))
00129     {
00130         cmbSerial->clear(); // cancello le entry della ComboBox
00131         cmbDate->clear(); // cancello le entry della ComboBox
00132         lstPartitions->clear(); // svuoto la lista delle partizioni
00133         radRev->setChecked(TRUE); // default restore da Rev
00134     }
00135 }
00136 
00137 
00138 void Restore::btnCancelRestore_clicked()
00139 {
00140     this->Close(); // chiudo la finestra di Restore
00141 }
00142 
00143 
00144 void Restore::cmbSerial_activated(const QString& string)
00145 {
00146     if ((!foundedRev) && (!foundedServer)) // se sul rev o sul server non ci sono directory
00147         return;
00148         
00149     dir->cd(string,TRUE); // entro nella directory della macchina
00150 
00151     // leggo le date di backup relative alla macchina selezionata da cmbSerial
00152     // nome directory (all'interno della directory della macchina) = data backup
00153     // la lista viene ordinata dal pia'¹ recente al pia'¹ vecchio
00154     dateList = dir->entryList(QDir::Dirs,QDir::Name | QDir::Reversed);
00155 
00156     cmbDate->clear(); // rimuovo gli elementi dal ComboBox delle date
00157 
00158     // riempio il combo relativo alle date di backup
00159     for ( QStringList::Iterator it = dateList.begin(); it != dateList.end(); ++it )
00160     {
00161         if ((*it != ".") && (*it != "..") && (*it != "lost+found")) // escludo dai seriali le directory . e ..
00162             cmbDate->insertItem(*it);
00163     }
00164 
00165     dir->cd("..",TRUE); // ritorno alla root
00166     
00167     if (cmbDate->count() > 0) // se c'e' almeno un elemento nella combobox
00168     {
00169         if (radRev->isChecked() == TRUE) // se sto cercando sul Rev
00170             foundedRev = TRUE;
00171         else // se sto cercando nella directory sul server
00172             foundedServer = TRUE;
00173     }
00174     else
00175     {
00176         if (radRev->isChecked() == TRUE) // se sto cercando sul Rev
00177             foundedRev = FALSE;
00178         else // se sto cercando nella directory sul server
00179             foundedServer = FALSE;
00180     }
00181 
00182     this->cmbDate_activated(cmbDate->currentText()); // aggiorno il ComboBox delle date
00183 }
00184 
00185 
00186 void Restore::cmbDate_activated(const QString& string)
00187 {
00188     QString fileName;
00189     QString currentPath; // memorizza il path corrente
00190     QStringList fileList; // lista file contenuti nella directory
00191     QStringList::iterator it; // iteratore per scorrere la lista dei file
00192     char workingPath[20]; // percorso in cui eseguire la ricerca
00193     
00194     if ((!foundedRev) && (!foundedServer)) // se sul rev o sul server non ci sono directory
00195         return;
00196         
00197     if (radRev->isChecked() == TRUE) // se sto cercando sul Rev
00198         strcpy(workingPath,pathRev);
00199     else // se sto cercando nella directory sul server
00200         strcpy(workingPath,pathServer);
00201     
00202 
00203     lstPartitions->clear(); // svuoto la lista delle partizioni
00204     
00205     // Leggo il nome del file della tabella delle partizioni
00206     currentPath = dir->path(); // salvo il path corrente
00207     dir->cd(workingPath + cmbSerial->currentText() + "/" + string,TRUE); // entro nella directory contenente le immagini
00208     fileList = dir->entryList("*.sf",QDir::Files,QDir::Name); // lista di tutti i file con estensione *.sf
00209     it = fileList.begin(); // inizio della lista
00210     fileName = *it; // file tabella delle partizioni = primo elemento (per come e' strutturata la gerarchia delle directory)
00211     dir->cd(currentPath); // ritorno al path precedente
00212     
00213     strcpy(deviceHDSource,FindHDSource(fileName).ascii()); // ricavo il device dell'hard disk sorgente
00214 
00215     // apro il file che contiene la struttura delle partizioni
00216     partitionTableFile->setName(workingPath + cmbSerial->currentText() + "/" + string + "/" + fileName);
00217 
00218     if (partitionTableFile->open(IO_ReadOnly)) // se il file viene aperto correttamente
00219     {
00220         QTextStream stream(partitionTableFile); // stream di testo per accedere al file
00221 
00222         vecPartitions.clear(); // svuoto il vettore dei dati delle partizioni
00223 
00224         while (!stream.atEnd())
00225         {
00226             QCheckListItem *q;
00227             partitionData p;
00228 
00229             this->ParsePartitionLine(stream.readLine(),p); // parsing della linea del file
00230 
00231             if ((p.name != "") && (p.size.toULong() > 0)) // se la partizione ha dimensione non nulla (= esiste)
00232             {
00233                 // creo un elemento nella lista per la partizione
00234                 q = new QCheckListItem(lstPartitions,p.name,QCheckListItem::CheckBox);
00235                 q->setOpen(TRUE); // espando la gerarchia, visualizzando i dati della partizione
00236 
00237                 if (p.id == "82") // se e' una partizione di swap
00238                 {
00239                     // non puo' essere selezionata perche' non verra'  ripristinata
00240                     q->setEnabled(FALSE);
00241                     p.id = "Swap";
00242                     vecPartitions.push_back(p); // salvo i dati della partizione
00243                 }
00244                 else if ((p.id == " f") || (p.id == " 5")) // se e' una partizione estesa
00245                 {
00246                     // non puo' essere selezionata perche' non verra' ripristinata
00247                     q->setEnabled(FALSE);
00248                     p.id = "Extended";
00249                 }
00250                 else // altra partizione (ext3, ext2, fat,...)
00251                 {
00252                     vecPartitions.push_back(p); // salvo i dati della partizione
00253                     q->setOn(TRUE); // selezionata di default
00254                 }
00255 
00256                 // creo un sottoelemento per i dettagli
00257                 if (p.bootable) // se la partizione e' di boot
00258                 {
00259                     new QListViewItem(lstPartitions->lastItem(),"Details:",p.start,p.size,p.id,"YES");
00260                 }
00261                 else
00262                 {
00263                     new QListViewItem(lstPartitions->lastItem(),"Details:",p.start,p.size,p.id,"NO");
00264                 }
00265             }
00266         }
00267         partitionTableFile->close(); // chiudo il file
00268         
00269         if (radRev->isChecked() == TRUE) // se sto cercando sul Rev
00270             foundedRev = TRUE;
00271         else // se sto cercando nella directory sul server
00272             foundedServer = TRUE;
00273         
00274     }
00275     else // se non viene trovato il file apro un dialog
00276     {
00277         QMessageBox::critical(this,"Error","Can't find partition table file!",
00278                               QMessageBox::Ok,QMessageBox::NoButton,QMessageBox::NoButton);
00279         
00280         if (radRev->isChecked() == TRUE) // se sto cercando sul Rev
00281             foundedRev = FALSE;
00282         else // se sto cercando nella directory sul server
00283             foundedServer = FALSE;
00284     }
00285 }
00286 
00287 
00288 void Restore::ParsePartitionLine(QString line, partitionData& p)
00289 {
00290     if (line.at(0) == '/' ) // le linee che descrivono una partizione cominciano per '/'
00291     {
00292         QString s;
00293 
00294         // ricavo il nome della partizione
00295         s = line.section(" : ",0,0);
00296         p.name = s.remove(0,5); // elimino "/dev/" prima del nome della partizione
00297 
00298         line = line.section(" : ",1,1); // elimino il nome della partizione dalla linea
00299 
00300         //ricavo il settore di start
00301         s = line.section(",",0,0);
00302         p.start = s.section("= ",1,1);
00303 
00304         //ricavo la dimensione
00305         s = line.section(",",1,1);
00306         p.size = s.section("= ",1,1);
00307 
00308         // ricavo il tipo di partizione
00309         s = line.section(",",2,2);
00310         p.id = s.section("=",1,1);
00311 
00312         // ricavo il flag bootable
00313         s = line.section(",",3,3);
00314         if (s == " bootable")
00315             p.bootable = TRUE;
00316         else
00317             p.bootable = FALSE;
00318     }
00319 }
00320 
00321 
00322 QString Restore::FindHDSource(QString fileName)
00323 {
00324     QString s;
00325 
00326     s = fileName.section("_",2,2); // ultima parte del nome del file es. hda.sf
00327     return s.section(".",0,0); // la prima parte corrisponde al device dell'hard disk sorgente
00328 }
00329 
00330 
00331 void Restore::btnStartRestore_clicked()
00332 {
00333     char workingPath[20]; // percorso in cui si trovano le immagini
00334 
00335     if (radRev->isChecked() == TRUE) // ripristino da Rev
00336         strcpy(workingPath,pathRev);
00337     else // ripristino da Server
00338         strcpy(workingPath,pathServer);
00339 
00340     if ( ((radRev->isChecked() == TRUE) && (foundedRev == TRUE)) || 
00341          ((radServer->isChecked() == TRUE) && (foundedServer == TRUE)) ) // se ho trovato delle immagini
00342     {    
00343         QString s; // stringa temporanea
00344 
00345         CenterWindow(this,output); // centro la finestra di output rispetto a quella di restore
00346         this->setEnabled(FALSE); // disabilito la finestra di restore
00347         this->hide(); // nascondo la finestra di Restore
00348         output->setEnabled(TRUE); // abilito la finestra di output
00349         output->show(); // visualizzo la finestra di output
00350 
00351         // directory di lavoro
00352         proc->setWorkingDirectory(workingPath + cmbSerial->currentText() + "/" + cmbDate->currentText() + "/");
00353 
00354         proc->clearArguments(); // cancello il comando precedente
00355         
00356         // disabilito tutte le partizioni di swap
00357         proc->addArgument("swapoff"); // comando
00358         proc->addArgument("-a"); // parametro
00359         proc->start(); // eseguo il comando
00360         
00361         proc->clearArguments(); // cancello il comando precedente
00362         
00363         // riabilito la partizione di swap di sistema
00364         proc->addArgument("swapon"); // comando
00365         proc->addArgument(swapPartition); // parametro
00366         proc->start(); // eseguo il comando
00367         
00368         proc->clearArguments(); // cancello il comando precedente
00369 
00370         // ripristino l'MBR
00371         proc->addArgument("dd"); // comando
00372         proc->addArgument("if=" + cmbSerial->currentText() + "_" + cmbDate->currentText() + "_" + deviceHDSource +
00373                           ".mbr"); // primo parametro
00374         s = "of=/dev/";
00375         proc->addArgument(s + deviceHDDestination); // secondo parametro
00376 
00377         // scrivo il comando concatenando i parametri
00378         QStringList sl = proc->arguments(); // lista dei parametri
00379         s = "";
00380         for ( QStringList::Iterator it = sl.begin(); it != sl.end(); ++it )
00381         {
00382             s += *it + " ";
00383         }
00384         output->appendCommand(s + "\n"); // visualizzo il comando
00385 
00386         proc->start(); // eseguo il comando
00387 
00388         while (proc->isRunning()) // aspetto la terminazione del comando
00389         {
00390             qApp->processEvents();
00391         }
00392 
00393         output->appendCommand("\n");
00394 
00395         proc->clearArguments(); // cancello il comando precedente
00396 
00397         // ripristino la tabella delle partizioni estese
00398         // (la ridirezione non funziona con QProcess e quindi lancio uno script che la esegue)
00399         proc->addArgument("ds4RestorePT"); // script
00400         proc->addArgument(deviceHDDestination); // primo parametro
00401         // secondo parametro
00402         proc->addArgument(cmbSerial->currentText() + "_" + cmbDate->currentText() + "_" + deviceHDSource + ".sf");
00403 
00404         // scrivo il comando
00405         sl = proc->arguments(); // lista dei parametri
00406         s = "";
00407         for ( QStringList::Iterator it = sl.begin(); it != sl.end(); ++it )
00408         {
00409             s += *it + " ";
00410         }
00411         output->appendCommand(s + "\n"); // visualizzo il comando
00412 
00413         proc->start(); // eseguo il comando
00414 
00415         while (proc->isRunning()) // aspetto la terminazione del comando
00416         {
00417             qApp->processEvents();
00418         }
00419 
00420         output->appendCommand("\n");
00421 
00422         // ripristino le partizioni selezionate
00423         QListViewItemIterator it(lstPartitions);
00424         while (it.current())
00425         {
00426             QListViewItem *item = it.current();
00427 
00428             if (((QCheckListItem*)it.current())->isOn()) // se la partizione e' selezionata
00429             {
00430                 proc->clearArguments(); // cancello il comando precedente
00431 
00432                 // eseguo lo script che lancia partimage per il restore della partizione selezionata
00433                 proc->addArgument("ds4PartimageRestore"); // script
00434                 proc->addArgument(workingPath + cmbSerial->currentText() + "/" + cmbDate->currentText()); // primo parametro
00435                 proc->addArgument(Src2Dest(item->text(0))); // secondo parametro
00436                 proc->addArgument(cmbSerial->currentText() + "_" + cmbDate->currentText() + "_" + item->text(0) + ".bz2"); // terzo parametro
00437 
00438                 // scrivo il comando
00439                 sl = proc->arguments(); // lista dei parametri
00440                 s = "";
00441                 for ( QStringList::Iterator it = sl.begin(); it != sl.end(); ++it )
00442                 {
00443                     s += *it + " ";
00444                 }
00445                 output->appendCommand(s + "\n"); // visualizzo il comando
00446 
00447                 proc->start(); // eseguo il comando
00448 
00449                 while (proc->isRunning()) // aspetto la terminazione del comando
00450                 {
00451                     qApp->processEvents();
00452                 }
00453 
00454                 output->appendCommand("\n");
00455             }
00456             it+=2; // salto la linea dei dettagli
00457         }
00458 
00459         output->appendCommand("\n");
00460 
00461         // formatto tutte le partizioni di swap
00462         if (chkSwap->isChecked())
00463         {
00464             for(vector<partitionData>::iterator itP = vecPartitions.begin();
00465                     itP != vecPartitions.end();
00466                     itP++)
00467             {
00468                 if ((*itP).id == "Swap") // se e' un partizione di swap
00469                 {
00470                     proc->clearArguments(); // cancello il comando precedente
00471 
00472                     // formatto la partizione di swap
00473                     proc->addArgument("mkswap"); // comando
00474                     proc->addArgument("-c"); // primo parametro
00475                     proc->addArgument("/dev/" + Src2Dest((*itP).name)); // secondo parametro
00476 
00477                     // scrivo il comando concatenando i parametri
00478                     QStringList sl = proc->arguments(); // lista dei parametri
00479                     s = "";
00480                     for ( QStringList::Iterator it = sl.begin(); it != sl.end(); ++it )
00481                     {
00482                         s += *it + " ";
00483                     }
00484                     output->appendCommand(s + "\n"); // visualizzo il comando
00485 
00486                     proc->start(); // eseguo il comando
00487 
00488                     while (proc->isRunning()) // aspetto la terminazione del comando
00489                     {
00490                         qApp->processEvents();
00491                     }
00492 
00493                     output->appendCommand("\n");
00494                 }
00495             }
00496         }
00497 
00498         // reinstallo GRUB
00499         if (chkGrub->isChecked())
00500         {
00501             proc->clearArguments(); // cancello il comando precedente
00502 
00503             // formatto la partizione di swap
00504             proc->addArgument("ds4RestoreGrub"); // comando
00505             proc->addArgument(deviceHDDestination); // primo parametro
00506 
00507             // scrivo il comando concatenando i parametri
00508             QStringList sl = proc->arguments(); // lista dei parametri
00509             s = "";
00510             for ( QStringList::Iterator it = sl.begin(); it != sl.end(); ++it )
00511             {
00512                 s += *it + " ";
00513             }
00514             output->appendCommand(s + "\n"); // visualizzo il comando
00515 
00516             proc->start(); // eseguo il comando
00517 
00518             while (proc->isRunning()) // aspetto la terminazione del comando
00519             {
00520                 qApp->processEvents();
00521             }
00522 
00523             output->appendCommand("\n");
00524         }
00525 
00526         QMessageBox::information(this,"Finish","Restore finished successfully!",
00527                                  QMessageBox::Ok,QMessageBox::NoButton,QMessageBox::NoButton);
00528 
00529         output->CloseEnabled(); // abilito la chiusura della finestra di output
00530     }
00531     else
00532     {
00533         // dialog di errore
00534         if (radRev->isChecked() == TRUE) // se sto cercando sul Rev
00535             QMessageBox::critical(this,"Error","There aren't images on Rev!",
00536                                   QMessageBox::Ok,QMessageBox::NoButton,QMessageBox::NoButton);
00537         else // se sto cercando nella directory sul server
00538             QMessageBox::critical(this,"Error","There aren't images on Server!",
00539                                   QMessageBox::Ok,QMessageBox::NoButton,QMessageBox::NoButton);
00540     }
00541     
00542 }
00543 
00544 QString Restore::Src2Dest(QString source)
00545 {
00546     QString dest;
00547     bool isNumber = false;
00548 
00549     dest = source.right(1); // l'ultimo carattere della stringa e' il numero della partizione
00550     dest.toUInt(&isNumber,10); // trasformo in numero
00551     if (isNumber == TRUE) // se la trasformazione e' corretta
00552         return (deviceHDDestination + dest); // concateno device di destinazione e numero partizione
00553     return "";
00554 }
00555 
00556 void Restore::readFromStdout()
00557 {
00558     output->appendOutput(proc->readStdout()); // stampa l'output del comando
00559 }
00560 
00561 
00562 void Restore::readFromStderr()
00563 {
00564     output->appendError(proc->readStderr()); // stampa l'erore del comando
00565 }
00566 
00567 
00568 void Restore::closeEvent (QCloseEvent *e)
00569 {
00570     e->accept(); // accetto l'evento di chiusura
00571     this->Close(); // chiudo la finestra di Restore
00572 }
00573 
00574 
00575 void Restore::Close()
00576 {
00577     this->hide(); // nasconde la finestra di restore
00578     mainWin->setEnabled(TRUE); // abilita la finestra principale
00579 }
00580 
00581 
00582 void Restore::btnMountRev_clicked()
00583 {
00584     if (*revMounted == TRUE) // se il Rev e' montato
00585     {
00586         if (UmountRev() == TRUE) // smonto il Rev
00587         {
00588             EjectRev(); // espulsione Rev
00589             *revMounted = FALSE;
00590             radRev->setEnabled(FALSE); // disabilito il radio button
00591             ledRevStatus->setColor(Qt::red); // led rosso
00592         }
00593         else
00594         {
00595             // dialog di errore
00596             QMessageBox::critical(this,"Error","Unable to umount Rev!",
00597                                   QMessageBox::Ok,QMessageBox::NoButton,QMessageBox::NoButton);
00598         }
00599     }
00600     else // se il Rev e' smontato
00601     {
00602         if (MountRev() == TRUE) // monto il Rev
00603         {
00604             *revMounted = TRUE;
00605             ledRevStatus->setColor(Qt::green); // led verde
00606             radRev->setEnabled(TRUE); // disabilito il radio button
00607             radRev->setChecked(TRUE); // selezione il restore dal Rev
00608         }
00609         else
00610         {
00611             // dialog di errore
00612             QMessageBox::critical(this,"Error","Unable to mount Rev!",
00613                                   QMessageBox::Ok,QMessageBox::NoButton,QMessageBox::NoButton);
00614         }
00615     }
00616     this->Init(revMounted,serverMounted); // inizializzo la finestra
00617 }
00618 
00619 
00620 void Restore::btnMountServer_clicked()
00621 {
00622     if (*serverMounted == TRUE) // se la directory condivisa e' montata
00623     {
00624         if (UmountServer() == TRUE) // smonto la directory condivisa
00625         {
00626             *serverMounted = FALSE;
00627             radServer->setEnabled(FALSE); // disabilito il radio button
00628             ledServerStatus->setColor(Qt::red); // led rosso
00629             radRev->setChecked(TRUE); // seleziono il radio button del Rev
00630         }
00631         else
00632         {
00633             // dialog di errore
00634             QMessageBox::critical(this,"Error","Unable to umount shared directory!",
00635                                   QMessageBox::Ok,QMessageBox::NoButton,QMessageBox::NoButton);
00636         }
00637     }
00638     else // se la directory condivisa e' smontata
00639     {
00640         if (MountServer() == TRUE) // monto la directory condivisa
00641         {
00642             *serverMounted = TRUE;
00643             ledServerStatus->setColor(Qt::green); // led verde
00644             radServer->setEnabled(TRUE); // abilito il radio button
00645             radServer->setChecked(TRUE); // selezione il restore dal Server
00646         }
00647         else
00648         {
00649             // dialog di errore
00650             QMessageBox::critical(this,"Error","Unable to mount shared directory!",
00651                                   QMessageBox::Ok,QMessageBox::NoButton,QMessageBox::NoButton);
00652         }
00653     }
00654     this->Init(revMounted,serverMounted); // inizializzo la finestra
00655 }
00656 
00657 void Restore::radRev_clicked()
00658 {
00659     this->Init(revMounted,serverMounted); // inizializzo la finestra
00660 }
00661 
00662 void Restore::radServer_clicked()
00663 {
00664     this->Init(revMounted,serverMounted); // inizializzo la finestra
00665 }
00666 
00667 
00668 
00669 
00670 
00671 
00672 #include "restore.moc"

Generato il Wed Jun 13 18:59:37 2007 per DS4CloneRestore da  doxygen 1.5.2