Copy the KDE 3.5 branch to branches/trinity for new KDE 3.5 features.

BUG:215923


git-svn-id: svn://anonsvn.kde.org/home/kde/branches/trinity/kdeadmin@1054174 283d02a7-25f6-0310-bc7c-ecb5cbfe19da

1 files changed, 1381 insertions, 0 deletions

diff --git a/kdat/KDatMainWindow.cpp b/kdat/KDatMainWindow.cpp
new file mode 100644
index 0000000..925ad92
--- /dev/null
+++ b/kdat/KDatMainWindow.cpp
@@ -0,0 +1,1381 @@
+// KDat - a tar-based DAT archiver
+// Copyright (C) 1998-2000  Sean Vyain, svyain@mail.tds.net
+// Copyright (C) 2001-2002  Lawrence Widman, kdat@cardiothink.com
+//
+// This program is free software; you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation; either version 2 of the License, or
+// (at your option) any later version.
+//
+// This program is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+//
+// You should have received a copy of the GNU General Public License
+// along with this program; if not, write to the Free Software
+// Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
+
+#include <assert.h>
+#include <time.h>
+#include <unistd.h>
+#include <sys/stat.h>
+#include <stdlib.h>
+
+#include <qdatetime.h>
+#include <qdir.h>
+#include <qfileinfo.h>
+#include <qkeycode.h>
+#include <qlayout.h>
+#include <qtextstream.h>
+
+#include <kapplication.h>
+#include <kiconloader.h>
+#include <kmenubar.h>
+#include <kpopupmenu.h>
+#include <ktoolbar.h>
+#include <kglobal.h>
+#include <kconfig.h>
+#include <kmessagebox.h>
+#include <kstringhandler.h>
+#include <kpushbutton.h>
+#include <kstdguiitem.h>
+
+#include "ArchiveInfoWidget.h"
+#include "BackupDlg.h"
+#include "BackupOptDlg.h"
+#include "BackupProfile.h"
+#include "BackupProfileInfoWidget.h"
+#include "BackupProfileManager.h"
+#include "FileInfoWidget.h"
+#include "FormatOptDlg.h"
+#include "ImageCache.h"
+#include "IndexDlg.h"
+#include "InfoShellWidget.h"
+#include "KDatMainWindow.h"
+#include "Node.h"
+#include "Options.h"
+#include "OptionsDlg.h"
+#include "Range.h"
+#include "Tape.h"
+#include "TapeDrive.h"
+#include "TapeFileInfoWidget.h"
+#include "TapeInfoWidget.h"
+#include "TapeManager.h"
+#include "Util.h"
+#include "VerifyDlg.h"
+#include "VerifyOptDlg.h"
+#include "kdat.h"
+#include "ktreeview.h"
+#include <klocale.h>
+#include <qsplitter.h>
+#include <kstatusbar.h>
+
+#include "KDatMainWindow.moc"
+
+KDatMainWindow* KDatMainWindow::_instance = 0;
+
+KDatMainWindow* KDatMainWindow::getInstance()
+{
+    if ( _instance == 0 ) {
+        _instance = new KDatMainWindow();
+    }
+    return _instance;
+}
+
+#define KDAT_HORIZONTAL_LAYOUT
+KDatMainWindow::KDatMainWindow()
+        : KMainWindow(0), _destroyed( FALSE )
+{
+#ifdef KDAT_HORIZONTAL_LAYOUT      /* 2002-01-20 LEW */
+    resize( 600, 600 );            /* was 600 by 400 */
+#else
+    resize( 600, 600 );
+#endif /* KDAT_HORIZONTAL_LAYOUT */
+
+    setIconText( i18n( "KDat: <no tape>" ) );
+    setCaption( i18n( "KDat: <no tape>" ) );
+
+    // Create object popup menus.
+    _tapeDriveMenu = new QPopupMenu();
+    _tapeDriveMenu->insertItem( i18n( "Mount Tape" )         , this, SLOT( fileMountTape() ) );
+    _tapeDriveMenu->insertItem( i18n( "Recreate Tape Index" ), this, SLOT( fileIndexTape() ) );
+    _tapeDriveMenu->insertSeparator();
+    _tapeDriveMenu->insertItem( i18n( "Format Tape..." ), this, SLOT( fileFormatTape() ) );
+
+    _archiveMenu = new QPopupMenu();
+    _archiveMenu->insertItem( i18n( "Delete Archive" ), this, SLOT( fileDeleteArchive() ) );
+
+    _mountedArchiveMenu = new QPopupMenu();
+    _mountedArchiveMenu->insertItem( i18n( "Verify..." )     , this, SLOT( fileVerify() ) );
+    _mountedArchiveMenu->insertItem( i18n( "Restore..." )    , this, SLOT( fileRestore() ) );
+    _mountedArchiveMenu->insertSeparator();
+    _mountedArchiveMenu->insertItem( i18n( "Delete Archive" ), this, SLOT( fileDeleteArchive() ) );
+
+    _mountedTapeFileMenu = new QPopupMenu();
+    _mountedTapeFileMenu->insertItem( i18n( "Verify..." ) , this, SLOT( fileVerify() ) );
+    _mountedTapeFileMenu->insertItem( i18n( "Restore..." ), this, SLOT( fileRestore() ) );
+
+    _localFileMenu = new QPopupMenu();
+    _localFileMenu->insertItem( i18n( "Backup..." ), this, SLOT( fileBackup() ) );
+
+    _tapeMenu = new QPopupMenu();
+    _tapeMenu->insertItem( i18n( "Delete Tape Index" ), this, SLOT( fileDeleteIndex() ) );
+
+    _backupProfileRootMenu = new QPopupMenu();
+    _backupProfileRootMenu->insertItem( i18n( "Create Backup Profile" ), this, SLOT( fileNewBackupProfile() ) );
+
+    _backupProfileMenu = new QPopupMenu();
+    _backupProfileMenu->insertItem( i18n( "Backup..." ), this, SLOT( fileBackup() ) );
+    _backupProfileMenu->insertSeparator();
+    _backupProfileMenu->insertItem( i18n( "Delete Backup Profile" ), this, SLOT( fileDeleteBackupProfile() ) );
+
+    _fileMenu = new QPopupMenu;
+    _fileMenu->insertItem( i18n( "Backup..." )            , this, SLOT( fileBackup() ) );
+    _fileMenu->insertItem( i18n( "Restore..." )           , this, SLOT( fileRestore() ) );
+    _fileMenu->insertItem( i18n( "Verify..." )            , this, SLOT( fileVerify() ) );
+    _fileMenu->insertItem( i18n( "Mount Tape" )           , this, SLOT( fileMountTape() ) );
+    _fileMenu->insertItem( i18n( "Recreate Tape Index" )  , this, SLOT( fileIndexTape() ) );
+    _fileMenu->insertItem( i18n( "Create Backup Profile" ), this, SLOT( fileNewBackupProfile() ) );
+    _fileMenu->insertSeparator();
+    _fileMenu->insertItem( i18n( "Delete Archive" )       , this, SLOT( fileDeleteArchive() ) );
+    _fileMenu->insertItem( i18n( "Delete Index" )         , this, SLOT( fileDeleteIndex() ) );
+    _fileMenu->insertItem( i18n( "Delete Backup Profile" ), this, SLOT( fileDeleteBackupProfile() ) );
+    _fileMenu->insertItem( i18n( "Format Tape..." )       , this, SLOT( fileFormatTape() ) );
+    _fileMenu->insertSeparator();
+    _fileMenu->insertItem( SmallIcon("exit"), i18n( "&Quit" )                , this, SLOT( fileQuit() ), CTRL + Key_Q );
+
+    _editMenu = new QPopupMenu;
+    _editMenu->insertItem( SmallIcon("configure"), i18n( "Configure KDat..." )       , this, SLOT( editPreferences() ) );
+
+    _menu = new KMenuBar( this );
+    _menu->insertItem( i18n( "&File" ), _fileMenu );
+    _menu->insertItem( i18n( "&Settings" ), _editMenu );
+    _menu->insertSeparator();
+    QString about = i18n( "KDat Version %1\n\nKDat is a tar-based tape archiver.\n\nCopyright (c) 1998-2000 Sean Vyain\nCopyright (c) 2001-2002 Lawrence Widman\nkdat@cardiothink.com" ).arg( KDAT_VERSION );
+    _menu->insertItem( i18n( "&Help" ), helpMenu( about ) );
+
+    _toolbar = new KToolBar( this );
+
+    _toolbar->insertButton( *ImageCache::instance()->getTapeUnmounted(), 0, SIGNAL( clicked( int ) ), this, SLOT( fileMountTape() ), TRUE, i18n( "Mount/unmount tape" ) );
+
+    _toolbar->insertSeparator();
+
+    _toolbar->insertButton( *ImageCache::instance()->getBackup() , 1, SIGNAL( clicked( int ) ), this, SLOT( fileBackup() ) , TRUE, i18n( "Backup" ) );
+    _toolbar->setButtonIconSet( 1, BarIconSet("kdat_backup"));
+    _toolbar->insertButton( *ImageCache::instance()->getRestore(), 2, SIGNAL( clicked( int ) ), this, SLOT( fileRestore() ), TRUE, i18n( "Restore" ) );
+    _toolbar->setButtonIconSet( 2, BarIconSet("kdat_restore"));
+    _toolbar->insertButton( *ImageCache::instance()->getVerify() , 3, SIGNAL( clicked( int ) ), this, SLOT( fileVerify() ) , TRUE, i18n( "Verify" ) );
+    _toolbar->setButtonIconSet( 3, BarIconSet("kdat_verify"));
+    addToolBar( _toolbar );
+
+    _statusBar = new KStatusBar( this );
+    _statusBar->insertItem( i18n( "Ready." ), 0 );
+
+#ifdef KDAT_HORIZONTAL_LAYOUT      /* 2002-01-20 LEW */
+    _panner = new QSplitter( QSplitter::Horizontal, this, "panner");
+#else
+    _panner = new QSplitter( QSplitter::Vertical, this, "panner");
+#endif /* KDAT_HORIZONTAL_LAYOUT */
+
+    // Create info viewers.
+    InfoShellWidget* infoShell = new InfoShellWidget( _panner );
+    _tapeInfo = new TapeInfoWidget( infoShell );
+    _archiveInfo = new ArchiveInfoWidget( infoShell );
+    _backupProfileInfo = new BackupProfileInfoWidget( infoShell );
+    _tapeFileInfo = new TapeFileInfoWidget( infoShell );
+    _fileInfo = new FileInfoWidget( infoShell );
+
+    // Now set up the tree
+    _tree = new KTreeView( _panner );
+    _tree->setExpandButtonDrawing( TRUE );
+
+#ifdef KDAT_HORIZONTAL_LAYOUT      /* 2002-01-20 LEW */
+    _tree->setMinimumWidth( 300 );
+    _panner->moveToFirst( _tree );
+#else
+    _tree->setMinimumHeight( 300 );
+#endif /* KDAT_HORIZONTAL_LAYOUT */
+
+    connect( _tree, SIGNAL( expanding( KTreeViewItem*, bool& ) ), this, SLOT( localExpanding( KTreeViewItem*, bool& ) ) );
+    connect( _tree, SIGNAL( expanded( int ) ), this, SLOT( localExpanded( int ) ) );
+    connect( _tree, SIGNAL( collapsed( int ) ), this, SLOT( localCollapsed( int ) ) );
+    connect( _tree, SIGNAL( selected( int ) ), this, SLOT( localSelected( int ) ) );
+    connect( _tree, SIGNAL( highlighted( int ) ), this, SLOT( localHighlighted( int ) ) );
+    connect( _tree, SIGNAL( popupMenu( int, const QPoint& ) ), this, SLOT( localPopupMenu( int, const QPoint& ) ) );
+
+    setCentralWidget( _panner );
+
+    _tree->insertItem( _tapeDriveNode = new TapeDriveNode() );
+    _tree->insertItem( _rootNode = new RootNode() );
+    _tree->insertItem( _backupProfileRootNode = new BackupProfileRootNode() );
+    _tree->insertItem( new TapeIndexRootNode() );
+
+    connect( TapeDrive::instance(), SIGNAL( sigStatus( const QString & ) ), this, SLOT( status( const QString & ) ) );
+
+    setTapePresent( FALSE );
+
+    connect( Options::instance(), SIGNAL( sigTapeDevice() ), this, SLOT( slotTapeDevice() ) );
+
+    connect( TapeManager::instance(), SIGNAL( sigTapeMounted() )  , this, SLOT( slotTapeMounted() ) );
+    connect( TapeManager::instance(), SIGNAL( sigTapeUnmounted() ), this, SLOT( slotTapeUnmounted() ) );
+
+    configureUI( 0 );
+}
+
+KDatMainWindow::~KDatMainWindow()
+{
+    _destroyed = TRUE;
+
+    if ( Options::instance()->getLockOnMount() ) {
+        TapeDrive::instance()->unlock();
+    }
+    delete _tapeDriveMenu;
+    delete _archiveMenu;
+    delete _mountedArchiveMenu;
+    delete _mountedTapeFileMenu;
+    delete _localFileMenu;
+    delete _tapeMenu;
+    delete _backupProfileRootMenu;
+    delete _backupProfileMenu;
+
+}
+
+void KDatMainWindow::popupTapeDriveMenu( const QPoint& p )
+{
+    // Configure menu before popping up.
+    if ( TapeManager::instance()->getMountedTape() ) {
+        _tapeDriveMenu->changeItem( i18n( "Unmount Tape" ), _tapeDriveMenu->idAt( 0 ) );
+        _tapeDriveMenu->setItemEnabled( _tapeDriveMenu->idAt( 1 ), TRUE );
+    } else {
+        _tapeDriveMenu->changeItem( i18n( "Mount Tape" ), _tapeDriveMenu->idAt( 0 ) );
+        _tapeDriveMenu->setItemEnabled( _tapeDriveMenu->idAt( 1 ), FALSE );
+    }
+
+    _tapeDriveMenu->popup( p );
+}
+
+void KDatMainWindow::popupArchiveMenu( const QPoint& p )
+{
+    _archiveMenu->popup( p );
+}
+
+void KDatMainWindow::popupMountedArchiveMenu( const QPoint& p )
+{
+    _mountedArchiveMenu->popup( p );
+}
+
+void KDatMainWindow::popupMountedTapeFileMenu( const QPoint& p )
+{
+    _mountedTapeFileMenu->popup( p );
+}
+
+void KDatMainWindow::popupLocalFileMenu( const QPoint& p )
+{
+    // Configure menu before popping up.
+    _localFileMenu->setItemEnabled( _localFileMenu->idAt( 0 ), ( TapeManager::instance()->getMountedTape() != 0 ) && ( !TapeDrive::instance()->isReadOnly() ) );
+
+    _localFileMenu->popup( p );
+}
+
+void KDatMainWindow::popupTapeMenu( const QPoint& p )
+{
+    _tapeMenu->popup( p );
+}
+
+void KDatMainWindow::popupBackupProfileRootMenu( const QPoint& p )
+{
+    _backupProfileRootMenu->popup( p );
+}
+
+void KDatMainWindow::popupBackupProfileMenu( const QPoint& p )
+{
+    // Configure menu before popping up.
+    _backupProfileMenu->setItemEnabled( _backupProfileMenu->idAt( 0 ), ( TapeManager::instance()->getMountedTape() != 0 ) && ( !TapeDrive::instance()->isReadOnly() ) );
+
+    _backupProfileMenu->popup( p );
+}
+
+void KDatMainWindow::hideInfo()
+{
+    _archiveInfo->hide();
+    _backupProfileInfo->hide();
+    _tapeInfo->hide();
+    _tapeFileInfo->hide();
+    _fileInfo->hide();
+}
+
+void KDatMainWindow::showTapeInfo( Tape* tape )
+{
+    assert( tape );
+
+    hideInfo();
+
+    _tapeInfo->setTape( tape );
+    _tapeInfo->show();
+}
+
+void KDatMainWindow::showArchiveInfo( Archive* archive )
+{
+    assert( archive );
+
+    hideInfo();
+
+    _archiveInfo->setArchive( archive );
+    _archiveInfo->show();
+}
+
+void KDatMainWindow::showBackupProfileInfo( BackupProfile* backupProfile )
+{
+    assert( backupProfile );
+
+    hideInfo();
+
+    _backupProfileInfo->setBackupProfile( backupProfile );
+    _backupProfileInfo->show();
+}
+
+void KDatMainWindow::showTapeFileInfo( File* file )
+{
+    assert( file );
+
+    hideInfo();
+
+    _tapeFileInfo->setFile( file );
+    _tapeFileInfo->show();
+}
+
+void KDatMainWindow::showFileInfo( const QString & name )
+{
+    assert( !name.isNull() );
+
+    hideInfo();
+
+    _fileInfo->setFile( name );
+    _fileInfo->show();
+}
+
+void KDatMainWindow::localExpanding( KTreeViewItem* item, bool& allow )
+{
+    ((Node*)item)->expanding( allow );
+}
+
+void KDatMainWindow::localExpanded( int index )
+{
+    ((Node*)_tree->itemAt( index ))->expanded();
+}
+
+void KDatMainWindow::localCollapsed( int index )
+{
+    ((Node*)_tree->itemAt( index ))->collapsed();
+}
+
+void KDatMainWindow::localSelected( int index )
+{
+    Node* item = (Node*)_tree->itemAt( index );
+
+    /* 2002-01-30 LEW: RG and I don't like the behavior in which
+       the subtree expands or contracts when a directory is selected
+       or unselected.
+       so make the tree look the same when we are done....
+       The goal is to redraw the icon to the left of the item.
+       There's gotta be a better way to do this. */
+    if ( item->isExpanded() ) {
+      _tree->collapseItem( index );
+      _tree->expandItem( index );   // 2002-01-30 LEW
+    } else {
+      _tree->expandItem( index );
+      _tree->collapseItem( index ); // 2002-01-30 LEW
+    }
+    // repaint();  // this doesn't work   2002-01-30 LEW
+    /* 2002-01-30 LEW: RG and I don't like this behavior */
+}
+
+void KDatMainWindow::localHighlighted( int index )
+{
+    Node* item = (Node*)_tree->itemAt( index );
+
+    if ( item ) {
+        item->selected();
+    }
+
+    configureUI( TapeManager::instance()->getMountedTape() );
+}
+
+void KDatMainWindow::localPopupMenu( int index, const QPoint& p )
+{
+    Node* item = (Node*)_tree->itemAt( index );
+    item->popupMenu( p );
+}
+
+void KDatMainWindow::fileBackup()
+{
+    BackupProfile backupProfile;
+
+    /* 2002-01-28 LEW */
+    // To the i18n translator: I apologize for this long text on the last day to submit
+    // i18n changes.  But, the program isn't very usable without this information.  Thanks. LEW
+    // (later today):  now the program works correctly!  Why?  Beats me!
+    QString msg = i18n("KDat will dump your files properly to tape, but may not be able\n"
+                       "to restore them. To restore your files by hand, you need to know\n"
+                       "the name of the *non-rewinding* version of your tape device %1.\n"
+			).arg(Options::instance()->getTapeDevice());
+    QString msg2 = i18n("For example, if your device is /dev/st0, the non-rewinding version\n"
+                       "is /dev/nst0. If your device name doesn't look like that, type\n"
+                       "\"ls -l %2\" in a terminal window to see the real name of your\n"
+                       "tape drive. Substitute that name for /dev/nst0 below.\n"
+                       "Open a terminal window and type the following:\n"
+                       "  tar tfv /dev/nst0; tar tfv /dev/nst0\n"
+                       "  tar xfv /dev/nst0\n"
+                       "The third call to \"tar\" will retrieve your data into your\n"
+                       "current directory. Please let us know if this happens to you!\n"
+                       " - KDat Maintenance Team\n"
+			).arg(Options::instance()->getTapeDevice());
+    msg = msg.append(msg2);
+    KMessageBox::sorry( this, msg);
+    /* 2002-01-28 LEW */
+
+    if ( ( _tree->getCurrentItem() ) && ( ((Node*)_tree->getCurrentItem())->isType( Node::BackupProfileNodeType ) ) ) {
+        BackupProfile* bp = ((BackupProfileNode*)_tree->getCurrentItem())->getBackupProfile();
+        backupProfile.setArchiveName( bp->getArchiveName() );
+        backupProfile.setWorkingDirectory( bp->getWorkingDirectory() );
+        backupProfile.setAbsoluteFiles( bp->getAbsoluteFiles() );
+        backupProfile.setOneFilesystem( bp->isOneFilesystem() );
+        backupProfile.setIncremental( bp->isIncremental() );
+        backupProfile.setSnapshotFile( bp->getSnapshotFile() );
+        backupProfile.setRemoveSnapshot( bp->getRemoveSnapshot() );
+    } else {
+        QString name;
+        name = i18n( "Archive created on %1" ).arg( KGlobal::locale()->formatDate(QDate::currentDate(), true) );
+        name = name.stripWhiteSpace();
+
+        QStringList files;
+        getBackupFiles( files );
+
+        backupProfile.setArchiveName( name );
+        backupProfile.setAbsoluteFiles( files );
+        backupProfile.setOneFilesystem( TRUE );
+        backupProfile.setIncremental( FALSE );
+        backupProfile.setSnapshotFile( "snapshot" );
+        backupProfile.setRemoveSnapshot( FALSE );
+    }
+
+    int ret = 0;
+    BackupOptDlg dlg( &backupProfile, this );
+    if ( dlg.exec() == QDialog::Accepted ) {
+        // Begin backup.
+        status( i18n( "Performing backup..." ) );
+        int size = calcBackupSize( dlg.getWorkingDirectory(), dlg.isOneFilesystem(), dlg.getRelativeFiles(), dlg.isIncremental(), dlg.getSnapshotFile(), dlg.getRemoveSnapshot() );
+
+        // Check to see whether user aborted the backup
+        if ( size < 0) {
+	  status( i18n( "Backup canceled." ) );
+	  return;
+	}
+
+        // Make sure the archive will fit on the tape.
+        int tapeSize = 1;
+        QPtrListIterator<Archive> i( TapeManager::instance()->getMountedTape()->getChildren() );
+        if ( i.toLast() != NULL ) {
+            tapeSize = i.current()->getEndBlock();
+            tapeSize = (int)((float)tapeSize / 1024.0 * (float)Options::instance()->getTapeBlockSize()) + 1;
+        }
+        if ( tapeSize + size >= TapeManager::instance()->getMountedTape()->getSize() ) {
+            // Warn user that tape is probably too short.
+            QString msg;
+            msg = i18n( "WARNING: The estimated archive size is %1 KB but "
+                        "the tape has only %2 KB of space!\n"
+                        "Back up anyway?" )
+              .arg(KGlobal::locale()->formatNumber(size, 0))
+              .arg(KGlobal::locale()->formatNumber(TapeManager::instance()->getMountedTape()->getSize() - tapeSize, 0 ));
+            int result = KMessageBox::warningContinueCancel( this,
+                               msg, i18n("Backup"), i18n("Backup") );
+            if ( result != KMessageBox::Continue) {
+                status( i18n( "Backup canceled." ) );
+                return;
+            }
+        }
+
+        if ( TapeDrive::instance()->getFile() < 0 ) {
+            // Rewind tape.
+            status( i18n( "Rewinding tape..." ) );
+            if ( !TapeDrive::instance()->rewind() ) {
+                KMessageBox::error( this,
+                      i18n("Cannot rewind tape.\nBackup aborted."),
+                      i18n("Backup Error"));
+                status( i18n( "Backup aborted." ) );
+                return;
+            }
+        }
+
+        // Go to end of tape.
+        status( i18n( "Skipping to end of tape..." ) );
+        if ( !TapeDrive::instance()->nextFile( TapeManager::instance()->getMountedTape()->getChildren().count() + 1 - TapeDrive::instance()->getFile() ) ) {
+            KMessageBox::error( this,
+                      i18n("Cannot get to end of tape.\nBackup aborted."),
+                      i18n("Backup Error"));
+            status( i18n( "Backup aborted." ) );
+            return;
+        }
+
+        status( i18n( "Backup in progress..." ) );
+        BackupDlg backupDlg( dlg.getArchiveName(), dlg.getWorkingDirectory(), dlg.getRelativeFiles(), dlg.isOneFilesystem(), dlg.isIncremental(), dlg.getSnapshotFile(), dlg.getRemoveSnapshot(), size, TapeManager::instance()->getMountedTape(), this );
+        ret = backupDlg.exec();
+
+//        status( i18n( "Rewinding tape..." ) );
+//        TapeDrive::instance()->rewind();
+//        if ( !TapeDrive::instance()->prevFile( 1 ) ) {
+//            status( i18n( "Rewinding tape..." ) );
+//            TapeDrive::instance()->rewind();
+//        }
+    }
+
+    // All done.
+    if ( ret == QDialog::Accepted ) {
+        status( i18n( "Backup complete." ) );
+    } else {
+        status( i18n( "Backup aborted." ) );
+    }
+}
+
+void KDatMainWindow::fileRestore()
+{
+    doVerify( TRUE );
+}
+
+void KDatMainWindow::fileVerify()
+{
+    doVerify( FALSE );
+}
+
+void KDatMainWindow::doVerify( bool restore )
+{
+    RangeableNode*      rangeableNode = 0;
+    MountedArchiveNode* archiveNode = 0;
+    QStringList files;
+    Archive* archive = 0;
+    // Check for marked files first.
+    for ( int i = _tapeDriveNode->childCount() - 1; i >= 0; i-- ) {
+        if ( ( ((SelectableNode*)_tapeDriveNode->childAt( i ))->isSelected() ) ||
+             ( ((SelectableNode*)_tapeDriveNode->childAt( i ))->hasSelectedChildren() )) {
+            archiveNode = (MountedArchiveNode*)_tapeDriveNode->childAt( i );
+            archive = archiveNode->getArchive();
+	    /* 2002-01-30 LEW */
+#ifdef DEBUG
+	    printf("KDatMainWindow::doVerify: %d node of %s: ", i,
+		   (SelectableNode*)_tapeDriveNode->getText().latin1() );
+            if( ((SelectableNode*)_tapeDriveNode->childAt( i ))->isSelected() ){
+	      printf("is completely selected\n");
+            } else {
+	      printf("is partially selected\n");
+            }
+#endif /* DEBUG */
+	    /* 2002-01-30 LEW */
+            break;
+        }
+    }
+
+    if ( !archiveNode ) {
+        if ( ((Node*)_tree->getCurrentItem())->isType( Node::RangeableNodeType ) ) {
+            rangeableNode = (RangeableNode*)_tree->getCurrentItem();
+            Node* parent = rangeableNode;
+            for ( ; !parent->isType( Node::MountedArchiveNodeType ); parent = (Node*)parent->getParent() );
+            assert( parent );
+            archive = ((MountedArchiveNode*)parent)->getArchive();
+        }
+    }
+
+    assert( archive );
+    QPtrListIterator<Archive> it( archive->getTape()->getChildren() );
+    int fileno;
+    for ( fileno = 1; ( it.current() ) && ( it.current() != archive ); ++it, fileno++ );
+
+    assert( archiveNode || rangeableNode );
+    assert( fileno > -1 );
+
+    RangeList ranges;
+    if ( rangeableNode ) {
+        QPtrListIterator<Range> it( rangeableNode->getRanges() );
+        for ( ; it.current(); ++it ) {
+            ranges.addRange( it.current()->getStart(), it.current()->getEnd() );
+        }
+        if ( rangeableNode->isType( Node::MountedArchiveNodeType ) ) {
+            // Make sure the mounted archive node has populated its children.
+            archiveNode = (MountedArchiveNode*)rangeableNode;
+            if ( archiveNode->childCount() == 0 ) {
+                bool dummy = TRUE;
+                archiveNode->expanding( dummy );
+            }
+
+            for ( int i = rangeableNode->childCount() - 1; i >= 0; i-- ) {
+                if ( ((Node*)rangeableNode->childAt( i ))->isType( Node::MountedTapeDirectoryNodeType ) ) {
+                    files.append( ((MountedTapeDirectoryNode*)rangeableNode->childAt( i ))->getFullPath() );
+                } else if ( ((Node*)rangeableNode->childAt( i ))->isType( Node::MountedTapeFileNodeType ) ) {
+                    files.append( ((MountedTapeFileNode*)rangeableNode->childAt( i ))->getFullPath() );
+                } else {
+                    assert( FALSE );
+                }
+            }
+        } else if ( rangeableNode->isType( Node::MountedTapeDirectoryNodeType ) ) {
+            files.append( ((MountedTapeDirectoryNode*)rangeableNode)->getFullPath() );
+        } else if ( rangeableNode->isType( Node::MountedTapeFileNodeType ) ) {
+            files.append( ((MountedTapeFileNode*)rangeableNode)->getFullPath() );
+        } else {
+            assert( FALSE );
+        }
+    } else {
+        // Compile a list of files to verify/restore.
+        QPtrStack<RangeableNode> stack;
+
+        // Make sure the mounted archive node has populated its children.
+        if ( archiveNode->childCount() == 0 ) {
+            bool dummy = TRUE;
+            archiveNode->expanding( dummy );
+        }
+
+        for ( int i = archiveNode->childCount() - 1; i >= 0; i-- ) {
+            stack.push( (RangeableNode*)archiveNode->childAt( i ) );
+        }
+        RangeableNode* sel = 0;
+        while ( stack.count() > 0 ) {
+            sel = stack.pop();
+            if ( sel->isSelected() ) {
+                QPtrListIterator<Range> it( sel->getRanges() );
+                for ( ; it.current(); ++it ) {
+                    ranges.addRange( it.current()->getStart(), it.current()->getEnd() );
+                }
+
+                if ( sel->isType( Node::MountedTapeDirectoryNodeType ) ) {
+                    files.append( ((MountedTapeDirectoryNode*)sel)->getFullPath() );
+                } else if ( sel->isType( Node::MountedTapeFileNodeType ) ) {
+                    files.append( ((MountedTapeFileNode*)sel)->getFullPath() );
+                } else {
+                    assert( FALSE );
+                }
+            } else if ( sel->hasSelectedChildren() ) {
+                for ( int i = sel->childCount() - 1; i >= 0; i-- ) {
+                    stack.push( (RangeableNode*)sel->childAt( i ) );
+                }
+            }
+        }
+    }
+
+    char buf[1024];
+    VerifyOptDlg dlg( getcwd( buf, 1024 ), files, restore, this );
+    if ( dlg.exec() == QDialog::Accepted ) {
+        if ( restore ) {
+            status( i18n( "Restore in progress..." ) );
+        } else {
+            status( i18n( "Verify in progress..." ) );
+        }
+        VerifyDlg verifyDlg( dlg.getWorkingDirectory(), fileno, ranges, restore, this );
+        int ret = verifyDlg.exec();
+
+        if ( ret == QDialog::Accepted ) {
+            if ( restore ) {
+                status( i18n( "Restore complete." ) );
+            } else {
+                status( i18n( "Verify complete." ) );
+            }
+        } else {
+            if ( restore ) {
+                status( i18n( "Restore aborted." ) );
+            } else {
+                status( i18n( "Verify aborted." ) );
+            }
+        }
+    }
+}
+
+void KDatMainWindow::fileMountTape()
+{
+    static QString msg;
+
+    // construct helpful error message (same as in fileFormatTape())
+    msg = i18n("There appears to be no tape in the drive %1. Please\n"
+               "check \"Edit->Preferences\" to make sure the\n"
+               "correct device is selected as the tape drive (e.g.\n"
+               "/dev/st0). If you hear the tape drive moving, wait\n"
+               "until it stops and then try mounting it again.")
+                 .arg(Options::instance()->getTapeDevice());
+
+    if ( !TapeManager::instance()->getMountedTape() ) {
+        if ( Options::instance()->getLoadOnMount() ) {
+            if ( !TapeDrive::instance()->load() ) {
+                KMessageBox::sorry( this, msg);
+                return;
+            }
+        }
+
+        if ( TapeDrive::instance()->isTapePresent() ) {
+            setTapePresent( TRUE );
+        } else {
+            KMessageBox::sorry( this, msg);
+        }
+    } else {
+        setTapePresent( FALSE );
+    }
+}
+
+void KDatMainWindow::fileIndexTape()
+{
+    int result = KMessageBox::warningContinueCancel( this,
+		       i18n( "The current tape index will be overwritten, continue?" ),
+                       i18n( "Index Tape"), i18n("Overwrite"));
+    if ( result == KMessageBox::Continue) {
+        TapeManager::instance()->getMountedTape()->clear();
+        IndexDlg dlg( TapeManager::instance()->getMountedTape(), this );
+        if ( dlg.exec() == QDialog::Accepted ) {
+            QString title;
+            title = i18n( "KDat: %1" ).arg( TapeManager::instance()->getMountedTape()->getName() );
+            setCaption( title );
+            setIconText( title );
+
+            status( i18n( "Index complete." ) );
+        } else {
+            status( i18n( "Index aborted." ) );
+        }
+    }
+}
+
+void KDatMainWindow::fileDeleteArchive()
+{
+    Node* sel = (Node*)_tree->getCurrentItem();
+    if ( ( !sel ) || ( !sel->isType( Node::ArchiveNodeType ) && !sel->isType( Node::MountedArchiveNodeType ) ) ) {
+        KMessageBox::sorry( this, i18n( "No archive is selected.\n"
+                                        "In order to delete an archive, the archive to be deleted "
+                                        "must be selected in the tree first." ));
+        return;
+    }
+
+    // Find the selected archive and see if it has any archives after it.
+    Archive* archive = 0;
+    if ( sel->isType( Node::ArchiveNodeType ) ) {
+        archive = ((ArchiveNode*)sel)->getArchive();
+    } else if ( sel->isType( Node::MountedArchiveNodeType ) ) {
+        archive = ((MountedArchiveNode*)sel)->getArchive();
+    }
+    assert( archive );
+
+    Tape*    tape    = archive->getTape();
+    QPtrListIterator<Archive> i( tape->getChildren() );
+    for ( ; i.current(); ++i ) {
+        if ( i.current() == archive ) {
+            break;
+        }
+    }
+    assert( i.current() );
+
+    ++i;
+    if ( i.current() ) {
+        // There are other archives after this one on the tape.
+        QString list;
+        for ( ; i.current(); ++i ) {
+            list.append( "\n        " );
+            list.append( i.current()->getName() );
+        }
+
+        QString msg =
+             i18n( "An archive cannot be removed from the middle of the tape. If\nthe archive '%1' is deleted then\nthe following archives will also be deleted:\n%2\n\nDelete all listed archives?" ).arg(archive->getName()).arg(list);
+        int result = KMessageBox::warningContinueCancel( this,
+             msg, i18n("Delete Archive"), i18n("Delete All"));
+        if (result == KMessageBox::Continue) {
+            tape->removeChild( archive );
+            emit status( i18n( "Archives deleted." ) );
+            if ( _tree->getCurrentItem() ) {
+                ((Node*)_tree->getCurrentItem())->selected();
+            }
+            configureUI( TapeManager::instance()->getMountedTape() );
+        }
+    } else {
+        // This is the last (known) archive on the tape.
+        QString msg =
+             i18n( "Really delete the archive '%1'?" ).arg(archive->getName());
+        int result = KMessageBox::warningContinueCancel( this,
+                              msg, i18n("Delete Archive"), i18n("Delete"));
+        if (result == KMessageBox::Continue) {
+            tape->removeChild( archive );
+            emit status( i18n( "Archive deleted." ) );
+            if ( _tree->getCurrentItem() ) {
+                ((Node*)_tree->getCurrentItem())->selected();
+            }
+            configureUI( TapeManager::instance()->getMountedTape() );
+        }
+    }
+}
+
+void KDatMainWindow::fileDeleteIndex()
+{
+    Node* sel = (Node*)_tree->getCurrentItem();
+    if ( ( !sel ) || ( !sel->isType( Node::TapeNodeType ) ) ) {
+        KMessageBox::sorry( this, i18n( "No tape index is selected.\n"
+                  "In order to delete a tape index, the tape index to be deleted "
+                  "must be selected in the tree first." ));
+        return;
+    }
+
+    Tape* tape = ((TapeNode*)sel)->getTape();
+    assert( tape );
+    if ( tape == TapeManager::instance()->getMountedTape() ) {
+        KMessageBox::sorry( this, i18n( "Tape is still mounted. "
+                  "The index for a mounted tape cannot be deleted.\n"
+                  "Unmount the tape and try again." ));
+        return;
+    }
+
+    QString msg =
+         i18n( "Really delete the index for '%1'?" ).arg(tape->getName());
+    int result = KMessageBox::warningContinueCancel( this,
+                    msg, i18n("Delete Tape Index"), i18n("Delete"));
+    if (result == KMessageBox::Continue) {
+        TapeManager::instance()->removeTape( tape );
+        emit status( i18n( "Tape index deleted." ) );
+        if ( _tree->getCurrentItem() ) {
+            ((Node*)_tree->getCurrentItem())->selected();
+        }
+        configureUI( TapeManager::instance()->getMountedTape() );
+    }
+}
+
+void KDatMainWindow::fileFormatTape()
+{
+    static QString msg;
+
+    // construct helpful error message (same as in fileMountTape())
+    msg = i18n("There appears to be no tape in the drive %1. Please\n"
+               "check \"Edit->Preferences\" to make sure the\n"
+               "correct device is selected as the tape drive (e.g.\n"
+               "/dev/st0). If you hear the tape drive moving, wait\n"
+               "until it stops and then try mounting it again.")
+                 .arg(Options::instance()->getTapeDevice());
+
+    if ( !TapeDrive::instance()->isTapePresent() ) {
+        KMessageBox::sorry( this, msg );
+        return;
+    }
+
+    if ( TapeDrive::instance()->isReadOnly() ) {
+        KMessageBox::sorry( this, i18n( "The tape in the drive is write protected.\nPlease disable write protection and try again." ));
+        return;
+    }
+
+    int result = KMessageBox::warningContinueCancel( this,
+                     i18n( "All data currently on the tape will be lost.\n"
+                           "Are you sure you want to continue?" ),
+                     i18n("Format Tape"), i18n("Format"));
+    if (result == KMessageBox::Continue ) {
+        QString name;
+        name = i18n( "Tape created on %1" ).arg(  KGlobal::locale()->formatDate(QDate::currentDate(), true) );
+        FormatOptDlg dlg( name.stripWhiteSpace(), this );
+        if ( dlg.exec() != QDialog::Accepted ) {
+            return;
+        }
+
+        // Delete old index file.
+        if ( TapeManager::instance()->getMountedTape() ) {
+            TapeManager::instance()->removeTape( TapeManager::instance()->getMountedTape() );
+            TapeManager::instance()->unmountTape();
+        }
+
+        Tape* tape = new Tape();
+        tape->setName( dlg.getName() );
+        tape->setSize( dlg.getSize() );
+
+        status( i18n( "Formatting tape..." ) );
+        tape->format();
+        TapeManager::instance()->addTape( tape );
+        status( i18n( "Format complete." ) );
+
+        setTapePresent( FALSE, FALSE );
+        setTapePresent( TRUE, FALSE );
+    }
+}
+
+void KDatMainWindow::fileNewBackupProfile()
+{
+    BackupProfile* backupProfile = new BackupProfile();
+
+    // Pick a unique name.
+    QString name;
+    for ( int i = 1; ; i++ ) {
+        name = i18n( "Backup Profile %1").arg( i );
+        QStringList list = BackupProfileManager::instance()->getBackupProfileNames();
+        QStringList::Iterator it = list.begin();
+        for ( ; it != list.end(); ++it ) {
+            if ( name == *it ) {
+                break;
+            }
+        }
+        if ( it == list.end() ) {
+            // Name is unique.
+            break;
+        }
+    }
+
+    QStringList files;
+    getBackupFiles( files );
+
+    backupProfile->setName( name );
+    backupProfile->setArchiveName( i18n( "Archive" ) );
+    backupProfile->setWorkingDirectory( Util::longestCommonPath( files ) );
+    if ( !backupProfile->getWorkingDirectory() ) {
+        backupProfile->setWorkingDirectory( "/" );
+    }
+    backupProfile->setAbsoluteFiles( files );
+    backupProfile->setOneFilesystem( TRUE );
+    backupProfile->setIncremental( FALSE );
+    backupProfile->setSnapshotFile( "snapshot" );
+    backupProfile->setRemoveSnapshot( FALSE );
+    backupProfile->save();
+
+    BackupProfileManager::instance()->addBackupProfile( backupProfile );
+
+    _backupProfileRootNode->setSelected( backupProfile );
+}
+
+void KDatMainWindow::fileDeleteBackupProfile()
+{
+    Node* sel = (Node*)_tree->getCurrentItem();
+    if ( ( !sel ) || ( !sel->isType( Node::BackupProfileNodeType ) ) ) {
+        KMessageBox::sorry( this, i18n( "In order to delete a backup profile, the backup profile to be deleted "
+                                        "must be selected in the tree first." ));
+        return;
+    }
+
+    BackupProfile* backupProfile = ((BackupProfileNode*)sel)->getBackupProfile();
+    assert( backupProfile );
+
+    QString msg =
+         i18n("Really delete backup profile '%1'?").arg(backupProfile->getName());
+    int result = KMessageBox::warningContinueCancel( this,
+                        msg, i18n("Delete Backup Profile"), i18n("Delete"));
+    if (result == KMessageBox::Continue) {
+        BackupProfileManager::instance()->removeBackupProfile( backupProfile );
+        emit status( i18n( "Backup profile deleted." ) );
+        if ( _tree->getCurrentItem() ) {
+            ((Node*)_tree->getCurrentItem())->selected();
+        }
+        configureUI( TapeManager::instance()->getMountedTape() );
+    }
+}
+
+void KDatMainWindow::fileQuit()
+{
+    KApplication::kApplication()->quit();
+}
+
+void KDatMainWindow::editPreferences()
+{
+    OptionsDlg dlg( this );
+    dlg.exec();
+}
+
+void KDatMainWindow::help()
+{
+    KApplication::kApplication()->invokeHelp( );
+}
+
+void KDatMainWindow::setTapePresent( bool tapePresent, bool eject )
+{
+    if ( TapeManager::instance()->getMountedTape() ) {
+        if ( !tapePresent ) {
+            TapeManager::instance()->unmountTape();
+
+            if ( ( eject ) && ( Options::instance()->getLockOnMount() ) ) {
+                TapeDrive::instance()->unlock();
+            }
+
+            if ( ( eject ) && ( Options::instance()->getEjectOnUnmount() ) ) {
+                TapeDrive::instance()->eject();
+            }
+
+            status( i18n( "Tape unmounted." ) );
+        }
+    } else {
+        if ( tapePresent ) {
+            status( i18n( "Reading tape header..." ) );
+            Tape* tape = TapeDrive::instance()->readHeader();
+
+            if ( tape ) {
+                TapeManager::instance()->mountTape( tape );
+            } else {
+                if ( TapeDrive::instance()->isReadOnly() ) {
+                    KMessageBox::sorry( this, i18n( "This tape has not been formatted by KDat." ));
+                } else {
+                    int result = KMessageBox::questionYesNo( this,
+                          i18n( "This tape has not been formatted by KDat.\n\nWould you like to format it now?" ), QString::null, i18n("Format"), i18n("Do Not Format"));
+                    if (result == KMessageBox::Yes) {
+                        fileFormatTape();
+                        return;
+                    }
+                }
+            }
+
+            if ( Options::instance()->getLockOnMount() ) {
+                TapeDrive::instance()->lock();
+            }
+
+            status( i18n( "Tape mounted." ) );
+        }
+    }
+}
+
+void KDatMainWindow::status( const QString & msg )
+{
+    _statusBar->changeItem( msg, 0 );
+    KApplication::kApplication()->processEvents();
+}
+
+void KDatMainWindow::show()
+{
+    KMainWindow::show();
+
+    hideInfo();
+}
+
+// 2002-01-21 LEW: returns backup size in KB, or -1 if user chose
+// to abort the backup.
+int KDatMainWindow::calcBackupSize( const QString& workingDir, bool local, const QStringList& files,
+                          bool incremental, const QString& snapshot, bool removeSnapshot )
+{
+    int return_value;
+
+    chdir( QFile::encodeName(workingDir) );
+
+    bool useSnapshot = !snapshot.isEmpty() && !removeSnapshot;
+
+    int tmp = 0;
+    if ( incremental && !removeSnapshot ) {
+        QFile snap( snapshot );
+        if ( snap.exists() && snap.open( IO_ReadOnly ) ) {
+            QTextStream t( &snap );
+            t >> tmp;
+        } else {
+            useSnapshot = FALSE;
+        }
+    }
+    QDateTime mtime;
+    mtime.setTime_t( tmp );
+
+    int size = 0;
+
+    /* 2002-01-24 LEW:  start of backup-cancel dialog */
+    create_backup_dialog();
+    stop_flag = FALSE;    // initialize the flag that tells us whether use
+                          // cancelled the backup via the dialog.
+    /* 2002-01-24 LEW:  end of backup-cancel dialog */
+
+    QStringList filesTmp = files;
+    QStringList::Iterator ii = filesTmp.begin();
+    for ( ; ii != filesTmp.end(); ++ii ) {
+
+        // Is this a normal file, or a directory?
+        QFileInfo finfo( *ii );
+        if ( !finfo.isDir() ) {
+            if ( ( !useSnapshot ) || ( finfo.lastModified() > mtime ) ) {
+                size += finfo.size() / 512;
+                if ( finfo.size() % 512 ) {
+                    size++;
+                }
+            }
+            continue;
+        }
+
+        QPtrStack<QString> dirStack;
+        dirStack.push( new QString( *ii ) );
+
+        // If stay on one file system, get device of starting directory.
+        dev_t device = 0;
+        struct stat info;
+        if ( local ) {
+            if ( lstat( QFile::encodeName(*ii), &info ) != 0 ) {
+                device = 0;
+            } else {
+                device = info.st_dev;
+            }
+        }
+
+        QString msg;
+        // msg.truncate( 4095 );
+        QDir dir;
+        const QFileInfoList* infoList;
+        while ( !dirStack.isEmpty() ) {
+	    if( stop_flag == TRUE ) break;
+            QString* path = dirStack.pop();
+            msg = i18n("Estimating backup size: %1, %2" )
+             .arg(Util::kbytesToString( size / 2 ))
+             .arg(KStringHandler::csqueeze(*path, 60));
+            status( msg );
+            KApplication::kApplication()->processEvents();
+            dir.setPath( *path );
+            infoList = dir.entryInfoList( QDir::Hidden | QDir::Files | QDir::Dirs, 0 );
+            if ( infoList ) {
+                QFileInfoListIterator i( *infoList );
+                for ( ; i.current(); ++i ) {
+                    if ( ( i.current()->fileName() != "." ) && ( i.current()->fileName() != ".." ) ) {
+                        size++;
+                        if ( i.current()->isSymLink() ) {
+                        } else if ( i.current()->isDir() ) {
+                            if ( local ) {
+                                if ( lstat( QFile::encodeName(i.current()->absFilePath()), &info ) == 0 ) {
+                                    if ( device == info.st_dev ) {
+                                        dirStack.push( new QString( i.current()->absFilePath() ) );
+                                    }
+                                }
+                            } else {
+                                dirStack.push( new QString( i.current()->absFilePath() ) );
+                            }
+                        } else if ( ( !useSnapshot ) || ( i.current()->lastModified() > mtime ) ) {
+                            size += i.current()->size() / 512;
+                            if ( i.current()->size() % 512 ) {
+                                size++;
+                            }
+                        }
+                    }
+                }
+            }
+        }
+    }
+
+    delete _backupdialog;   // we're done, so zap this widget
+
+    // Convert size in tar blocks to size in kbytes.
+    return_value = size / 2;
+
+    if( stop_flag == TRUE ) return_value = -1;
+
+    return return_value;
+}
+
+void KDatMainWindow::getBackupFiles( QStringList& files )
+{
+    if ( !_rootNode->isSelected() && !_rootNode->hasSelectedChildren() ) {
+        // Backup the entire subtree.
+        if ( ( _tree->getCurrentItem() ) && ( ((Node*)_tree->getCurrentItem())->isType( Node::ArchiveableNodeType ) ) ) {
+            files.append( ((ArchiveableNode*)_tree->getCurrentItem())->getFullPath() );
+        }
+    } else {
+        // Compile a list of files to backup.
+        QPtrStack<ArchiveableNode> stack;
+        stack.push( _rootNode );
+        ArchiveableNode* sel = 0;
+        while ( stack.count() > 0 ) {
+            sel = stack.pop();
+            if ( sel->isSelected() ) {
+                files.append( sel->getFullPath() );
+            } else if ( sel->hasSelectedChildren() ) {
+                for ( int i = sel->childCount() - 1; i >= 0; i-- ) {
+                    stack.push( (ArchiveableNode*)sel->childAt( i ) );
+                }
+            }
+        }
+    }
+}
+
+void KDatMainWindow::setBackupFiles( const QStringList& files )
+{
+    _rootNode->setSelected( FALSE );
+
+    QString tmp;
+    QStringList filesTmp = files;
+    QStringList::Iterator it = filesTmp.begin();
+    for ( ; it != filesTmp.end(); ++it ) {
+        ArchiveableNode* n = _rootNode;
+        while ( n ) {
+            if ( n->getFullPath() == *it ) {
+                n->setSelected( TRUE );
+                n = 0;
+            } else {
+                if ( n->childCount() == 0 ) {
+                    bool dummy = TRUE;
+                    n->expanding( dummy );
+                }
+                int i;
+                for ( i = n->childCount() - 1; i >=0; i-- ) {
+                    tmp = ((ArchiveableNode*)n->childAt( i ))->getFullPath();
+                    if ( tmp == (*it).left( tmp.length() ) ) {
+                        n = (ArchiveableNode*)n->childAt( i );
+                        break;
+                    }
+                }
+                if ( i < 0 ) {
+                    n = 0;
+                }
+            }
+        }
+    }
+}
+
+void KDatMainWindow::slotTapeDevice()
+{
+    setTapePresent( FALSE );
+}
+
+void KDatMainWindow::slotTapeMounted()
+{
+    configureUI( TapeManager::instance()->getMountedTape() );
+}
+
+void KDatMainWindow::slotTapeUnmounted()
+{
+    configureUI( 0 );
+}
+
+void KDatMainWindow::configureUI( Tape* tape )
+{
+    if ( _destroyed ) {
+        return;
+    }
+
+    Node* sel  = (Node*)_tree->getCurrentItem();
+
+    // Title bar
+    if ( tape ) {
+        QString title;
+        title = i18n( "KDat: %1" ).arg(tape->getName());
+        setCaption( title );
+        setIconText( title );
+    } else {
+        setCaption( i18n( "KDat: <no tape>" ) );
+        setIconText( i18n( "KDat: <no tape >" ) );
+    }
+
+    // Backup
+    bool canBackup = ( tape ) && ( !TapeDrive::instance()->isReadOnly() ) &&
+        ( ( ( sel ) && ( sel->isType( Node::ArchiveableNodeType ) || sel->isType( Node::BackupProfileNodeType ) ) ) ||
+          ( _rootNode->isSelected() || _rootNode->hasSelectedChildren() ) );
+    _toolbar->setItemEnabled( 1, canBackup );
+    _fileMenu->setItemEnabled( _fileMenu->idAt( 0 ), canBackup );
+
+    // Restore/verify
+    bool canRestore = ( tape ) && ( sel ) && sel->isType( Node::RangeableNodeType );
+    if ( !canRestore ) {
+        for ( int i = _tapeDriveNode->childCount() - 1; i >= 0; i-- ) {
+            if ( ( ((SelectableNode*)_tapeDriveNode->childAt( i ))->isSelected() ) ||
+                 ( ((SelectableNode*)_tapeDriveNode->childAt( i ))->hasSelectedChildren() )) {
+                canRestore = TRUE;
+                break;
+            }
+        }
+    }
+    if ( canRestore ) {
+      // 2002-01-30 LEW: check Node *sel because we can have canRestore==true
+      // even if sel==NULL when a child is selected (see loop above).
+      if( sel != (Node *)0x0 )
+      {
+        for ( Node* parent = (Node*)sel->getParent();
+              ( parent ) && ( parent->getParent() );
+              parent = (Node*)parent->getParent() ) {
+            if ( parent->isType( Node::TapeNodeType ) ) {
+                canRestore = FALSE;
+            }
+        }
+      }
+      // 2002-01-30 LEW: see if we ever get here...
+      else
+	{
+	printf("Found sel==0x0 in %s %d\n", __FILE__, __LINE__);
+	}
+      // 2002-01-30 LEW
+
+    }
+    _toolbar->setItemEnabled( 2, canRestore );
+    _toolbar->setItemEnabled( 3, canRestore );
+    _fileMenu->setItemEnabled( _fileMenu->idAt( 1 ), canRestore );
+    _fileMenu->setItemEnabled( _fileMenu->idAt( 2 ), canRestore );
+
+    // Mount/unmount tape
+    if ( tape ) {
+        _toolbar->setButtonPixmap( 0, *ImageCache::instance()->getTapeMounted() );
+        _fileMenu->changeItem( i18n( "Unmount Tape" ), _fileMenu->idAt( 3 ) );
+    } else {
+        _toolbar->setButtonPixmap( 0, *ImageCache::instance()->getTapeUnmounted() );
+        _fileMenu->changeItem( i18n( "Mount Tape" ), _fileMenu->idAt( 3 ) );
+    }
+
+    // Index tape
+    _fileMenu->setItemEnabled( _fileMenu->idAt( 4 ), tape != NULL );
+
+    // Delete archive
+    _fileMenu->setItemEnabled( _fileMenu->idAt( 7 ), ( sel ) && sel->isType( Node::ArchiveNodeType ) );
+
+    // Delete index
+    _fileMenu->setItemEnabled( _fileMenu->idAt( 8 ), ( sel ) && sel->isType( Node::TapeNodeType ) );
+
+    // Delete backup profile
+    _fileMenu->setItemEnabled( _fileMenu->idAt( 9 ), ( sel ) && sel->isType( Node::BackupProfileNodeType ) );
+
+    // Format tape
+    _fileMenu->setItemEnabled( _fileMenu->idAt( 10 ), TapeManager::instance()->getMountedTape() && !TapeDrive::instance()->isReadOnly() );
+}
+
+void KDatMainWindow::readProperties( KConfig* config )
+{
+  QValueList<int> sizes;
+  sizes << config->readNumEntry( "panner", 50 );
+  _panner->setSizes( sizes );
+}
+
+void KDatMainWindow::saveProperties( KConfig* config )
+{
+    config->writeEntry( "panner", _panner->sizes().first());
+}
+
+// Create the dialog that lets user cancel estimation of backup size
+void KDatMainWindow::create_backup_dialog()
+{
+  /* 2002-01-24 LEW:  start of backup-cancel dialog */
+  static QString stop_button_text, stop_button_caption;
+  stop_button_text =
+    i18n("Click \"CANCEL\" to stop the backup process.\n"
+	 "For example, you may quickly see that the size of\n"
+	 "the files you selected will exceed the size of the\n"
+	 "backup tape, and may then decide to stop and remove\n"
+	 "some files from your list of files to backup.\n\n"
+         "Click \"Continue\" to remove this message while\n"
+         "continuing the backup.");
+  stop_button_caption = i18n("Stop estimating backup size");
+
+        // gotta put a callback in here.  Probably need to create a
+        // dialog object  2002-01-22 LEW
+  _backupdialog = new KDialog( this, "backupdialog", false );
+  _backupdialog->setCaption( stop_button_caption );
+  //  _backupdialog->resize(370,200);  /* 2002-01-28 LEW */
+  _backupdialog->resize(370,260);
+
+  _lbl = new QLabel( stop_button_text, _backupdialog );
+  //  _lbl->setGeometry( QRect( 30, 20, 350, 140 ) );  /* 2002-01-28 LEW */
+  _lbl->setGeometry( QRect( 30, 20, 350, 200 ) );
+
+  _cancel = new KPushButton( KStdGuiItem::cancel(), _backupdialog );
+  _cancel->setFixedSize( 80, _cancel->sizeHint().height() );
+  _cancel->setEnabled( TRUE );
+  /* 2002-01-24 LEW: looks like we can't increase the button width
+     to accomodate a wider message :( */
+  //  _cancel->setGeometry( QRect( 50, 170, 0, 0 ) );   /* 2002-01-28 LEW */
+  _cancel->setGeometry( QRect( 50, 230, 0, 0 ) );
+  connect( _cancel, SIGNAL( clicked() ), this, SLOT( backupCancel() ) );
+
+  _continue = new KPushButton( KStdGuiItem::cont(), _backupdialog );
+  _continue->setFixedSize( 80, _continue->sizeHint().height() );
+  _continue->setEnabled( TRUE );
+  _continue->setDefault( TRUE );
+  //  _continue->setGeometry( QRect( 200, 170, 0, 0 ) );   /* 2002-01-28 LEW */
+  _continue->setGeometry( QRect( 200, 230, 0, 0 ) );
+  connect( _continue, SIGNAL( clicked() ), this, SLOT( backupContinue() ) );
+
+  _backupdialog->show();
+}
+
+// stop calculating the backup size and hide the dialog screen
+void KDatMainWindow::backupCancel()
+{
+  stop_flag = TRUE;
+  _backupdialog->hide();
+}
+
+// continue calculating the backup size and hide the dialog screen
+void KDatMainWindow::backupContinue()
+{
+  _backupdialog->hide();
+}