lib/marble/BookmarkManagerDialog.cpp

0001 // SPDX-License-Identifier: LGPL-2.1-or-later
0002 //
0003 // SPDX-FileCopyrightText: 2010 Dennis Nienhüser <nienhueser@kde.org>
0004 // SPDX-FileCopyrightText: 2012 Thibaut Gridel <tgridel@free.fr>
0005 //
0006
0007 #include "BookmarkManagerDialog.h"
0008 #include "BookmarkManager.h"
0009 #include "BookmarkManager_p.h"
0010 #include "BranchFilterProxyModel.h"
0011 #include "EditBookmarkDialog.h"
0012 #include "FileManager.h"
0013 #include "GeoDataCoordinates.h"
0014 #include "GeoDataDocument.h"
0015 #include "GeoDataLookAt.h"
0016 #include "GeoDataExtendedData.h"
0017 #include "GeoDataFolder.h"
0018 #include "GeoDataPlacemark.h"
0019 #include "GeoDataPoint.h"
0020 #include "GeoDataStyle.h"
0021 #include "GeoDataIconStyle.h"
0022 #include "GeoDataTreeModel.h"
0023 #include "GeoDataTypes.h"
0024 #include "GeoDataDocumentWriter.h"
0025 #include "MarbleDirs.h"
0026 #include "MarbleDebug.h"
0027 #include "MarbleModel.h"
0028 #include "NewBookmarkFolderDialog.h"
0029 #include "MarblePlacemarkModel.h"
0030 #include <KmlElementDictionary.h>
0031
0032 #include <QPointer>
0033 #include <QFile>
0034 #include <QSortFilterProxyModel>
0035 #include <QFileDialog>
0036 #include <QMessageBox>
0037
0038 namespace Marble {
0039
0040 /*
0041  * The two list views use the model data like this:
0042  *
0043  *                                     (folder filter)
0044  *
0045  *                                     QSortFilterProxyModel => Folders View
0046  *                                   /         |
0047  * bookmarks.kml => GeoDataTreeModel           |  current folder sets filter
0048  *                                   \        \ /
0049  *                                     BranchFilterModel => Bookmarks View
0050  *
0051  *                                     (placemark filter)   (placemark list)
0052  *
0053  */
0054 class BookmarkManagerDialogPrivate {
0055     Q_DECLARE_TR_FUNCTIONS(BookmarkManagerDialogPrivate)
0056
0057 public:
0058     BookmarkManagerDialog *m_parent;
0059
0060     BookmarkManager *const m_manager;
0061
0062     GeoDataTreeModel *const m_treeModel;
0063
0064     QSortFilterProxyModel m_folderFilterModel;
0065
0066     QPersistentModelIndex m_selectedFolder;
0067
0068     BranchFilterProxyModel m_branchFilterModel;
0069
0070     BookmarkManagerDialogPrivate( BookmarkManagerDialog* parent, MarbleModel *model );
0071
0072     void initializeFoldersView( GeoDataTreeModel* treeModel );
0073
0074     void initializeBookmarksView( GeoDataTreeModel* treeModel );
0075
0076     void handleFolderSelection( const QModelIndex &index );
0077
0078     void updateButtonState();
0079
0080     void addNewFolder();
0081
0082     void renameFolder();
0083
0084     void deleteFolder();
0085
0086     void editBookmark();
0087
0088     void deleteBookmark();
0089
0090     void discardChanges();
0091
0092     QModelIndex bookmarkTreeIndex( const QModelIndex &bookmark ) const;
0093
0094     QModelIndex folderTreeIndex( const QModelIndex &index ) const;
0095     GeoDataContainer* selectedFolder();
0096
0097     void selectFolder( const QString &name = QString(), const QModelIndex &index = QModelIndex() );
0098
0099     void importBookmarksRecursively( GeoDataContainer *source, GeoDataContainer *destination,
0100                                      bool &replaceAll, bool &skipAll );
0101
0102     GeoDataDocument* bookmarkDocument();
0103 };
0104
0105 BookmarkManagerDialogPrivate::BookmarkManagerDialogPrivate( BookmarkManagerDialog* parent, MarbleModel *model ) :
0106     m_parent( parent ),
0107     m_manager( model->bookmarkManager() ),
0108     m_treeModel( model->treeModel() ),
0109     m_folderFilterModel(),
0110     m_branchFilterModel()
0111 {
0112     // nothing to do
0113 }
0114
0115 /// react to clicking on the folder index (of folderfiltermodel fame)
0116 /// consequence is selecting this folder, or unselecting it and going to root folder
0117 void BookmarkManagerDialogPrivate::handleFolderSelection( const QModelIndex &index )
0118 {
0119     if( !index.isValid() ) {
0120         return;
0121     }
0122     Q_ASSERT( index.isValid() );
0123     Q_ASSERT( index.model() == &m_folderFilterModel );
0124     if( m_selectedFolder.isValid() &&
0125         m_parent->foldersTreeView->selectionModel()->selectedIndexes().contains( m_selectedFolder ) ) {
0126         m_selectedFolder = QModelIndex();
0127         m_parent->foldersTreeView->selectionModel()->clear();
0128         selectFolder();
0129     } else {
0130         m_selectedFolder = index;
0131         m_branchFilterModel.setBranchIndex( m_treeModel, folderTreeIndex( index ) );
0132         m_parent->bookmarksListView->setRootIndex(
0133                     m_branchFilterModel.mapFromSource( folderTreeIndex( index ) ) );
0134         m_parent->bookmarksListView->selectionModel()->clear();
0135     }
0136 }
0137
0138 void BookmarkManagerDialogPrivate::updateButtonState()
0139 {
0140     bool const hasFolderSelection = !m_parent->foldersTreeView->selectionModel()->selectedIndexes().isEmpty();
0141     m_parent->renameFolderButton->setEnabled( hasFolderSelection );
0142     m_parent->removeFolderButton->setEnabled( hasFolderSelection );
0143
0144     bool const hasBookmarkSelection = !m_parent->bookmarksListView->selectionModel()->selectedIndexes().isEmpty();
0145     m_parent->editBookmarkButton->setEnabled( hasBookmarkSelection );
0146     m_parent->removeBookmarkButton->setEnabled( hasBookmarkSelection );
0147 }
0148
0149 void BookmarkManagerDialogPrivate::addNewFolder()
0150 {
0151     QPointer<NewBookmarkFolderDialog> dialog = new NewBookmarkFolderDialog( m_parent );
0152     if ( dialog->exec() == QDialog::Accepted && !dialog->folderName().isEmpty() ) {
0153         m_manager->addNewBookmarkFolder( selectedFolder(), dialog->folderName() );
0154         selectFolder( dialog->folderName(), m_selectedFolder );
0155     }
0156     delete dialog;
0157 }
0158
0159 void BookmarkManagerDialogPrivate::renameFolder()
0160 {
0161     GeoDataFolder *folder = geodata_cast<GeoDataFolder>(selectedFolder());
0162     if ( folder ) {
0163         QPointer<NewBookmarkFolderDialog> dialog = new NewBookmarkFolderDialog( m_parent );
0164         dialog->setFolderName( folder->name() );
0165         QPersistentModelIndex parentIndex = m_selectedFolder.parent();
0166         if ( dialog->exec() == QDialog::Accepted ) {
0167             m_manager->renameBookmarkFolder( folder, dialog->folderName() );
0168         }
0169         selectFolder( dialog->folderName(), parentIndex );
0170         delete dialog;
0171     }
0172 }
0173
0174 void BookmarkManagerDialogPrivate::deleteFolder()
0175 {
0176     GeoDataFolder *folder = geodata_cast<GeoDataFolder>(selectedFolder());
0177     if ( folder ) {
0178         if ( folder->size() > 0 ) {
0179             QString const text = tr( "The folder %1 is not empty. Removing it will delete all bookmarks it contains. Are you sure you want to delete the folder?" ).arg( folder->name() );
0180             if (QMessageBox::question(m_parent, tr("Remove Folder"), text, QMessageBox::Yes, QMessageBox::No) != QMessageBox::Yes) {
0181                 return;
0182             }
0183         }
0184
0185         // take note of the parentIndex before removing the folder
0186         QString parent = static_cast<GeoDataContainer*>(folder->parent())->name();
0187         QPersistentModelIndex greatParentIndex = m_selectedFolder.parent().parent();
0188         m_manager->removeBookmarkFolder( folder );
0189         selectFolder( parent, greatParentIndex);
0190     }
0191 }
0192
0193 void BookmarkManagerDialogPrivate::editBookmark()
0194 {
0195     QModelIndexList selection = m_parent->bookmarksListView->selectionModel()->selectedIndexes();
0196     if ( selection.size() == 1 ) {
0197         QModelIndex index = m_branchFilterModel.mapToSource( selection.first() );
0198         Q_ASSERT( index.isValid() );
0199         GeoDataObject* object = qvariant_cast<GeoDataObject*>( index.data( MarblePlacemarkModel::ObjectPointerRole ) );
0200         Q_ASSERT( object );
0201         GeoDataPlacemark *bookmark = geodata_cast<GeoDataPlacemark>(object);
0202         // do not try to edit folders
0203         if ( !bookmark ) {
0204             return;
0205         }
0206         Q_ASSERT( bookmark );
0207         QModelIndex treeIndex = index;
0208         Q_ASSERT( treeIndex.isValid() );
0209         QModelIndex folderIndex = treeIndex.parent();
0210         Q_ASSERT( folderIndex.isValid() );
0211         GeoDataObject* folderObject = qvariant_cast<GeoDataObject*>( folderIndex.data( MarblePlacemarkModel::ObjectPointerRole ) );
0212         Q_ASSERT( folderObject );
0213         GeoDataFolder* folder = geodata_cast<GeoDataFolder>(folderObject);
0214         Q_ASSERT( folder );
0215
0216         QPointer<EditBookmarkDialog> dialog = new EditBookmarkDialog( m_manager, m_parent );
0217         dialog->setName( bookmark->name() );
0218         if ( bookmark->lookAt() ) {
0219             dialog->setRange( bookmark->lookAt()->range() );
0220         }
0221         dialog->setCoordinates( bookmark->coordinate() );
0222         dialog->setDescription( bookmark->description() );
0223         dialog->setFolderName( folder->name() );
0224         dialog->setIconLink( bookmark->style()->iconStyle().iconPath() );
0225         if ( dialog->exec() == QDialog::Accepted ) {
0226             bookmark->setName( dialog->name() );
0227             bookmark->setDescription( dialog->description() );
0228             bookmark->setCoordinate( dialog->coordinates() );
0229             GeoDataStyle::Ptr newStyle(new GeoDataStyle( *bookmark->style() ));
0230             newStyle->iconStyle().setIconPath( dialog->iconLink() );
0231             bookmark->setStyle( newStyle );
0232             if ( bookmark->lookAt() ) {
0233                 bookmark->lookAt()->setCoordinates( dialog->coordinates() );
0234                 bookmark->lookAt()->setRange( dialog->range() );
0235             } else if ( dialog->range() ) {
0236                 GeoDataLookAt *lookat = new GeoDataLookAt;
0237                 lookat->setCoordinates( dialog->coordinates() );
0238                 lookat->setRange( dialog->range() );
0239                 bookmark->setAbstractView( lookat );
0240             }
0241             m_manager->updateBookmark( bookmark );
0242
0243             if (folder->name() != dialog->folder()->name() ) {
0244                 GeoDataPlacemark newBookmark( *bookmark );
0245                 m_manager->removeBookmark( bookmark );
0246                 m_manager->addBookmark( dialog->folder(), newBookmark );
0247             }
0248         }
0249         delete dialog;
0250     }
0251 }
0252
0253 void BookmarkManagerDialogPrivate::deleteBookmark()
0254 {
0255     const QModelIndexList selection = m_parent->bookmarksListView->selectionModel()->selectedIndexes();
0256
0257     if (selection.size() != 1) {
0258         return;
0259     }
0260
0261     const QModelIndex bookmarkIndex = m_branchFilterModel.mapToSource(selection.first());
0262     GeoDataFolder *folder = geodata_cast<GeoDataFolder>(selectedFolder());
0263     if (!folder) {
0264         return;
0265     }
0266
0267     GeoDataPlacemark *bookmark = geodata_cast<GeoDataPlacemark>(folder->child(bookmarkIndex.row()));
0268     if (!bookmark) {
0269         return;
0270     }
0271
0272     m_manager->removeBookmark(bookmark);
0273 }
0274
0275 void BookmarkManagerDialogPrivate::discardChanges()
0276 {
0277     m_manager->loadFile( "bookmarks/bookmarks.kml" );
0278 }
0279
0280 /// selects the folder name from its parent (of folder filter fame)
0281 void BookmarkManagerDialogPrivate::selectFolder( const QString &name, const QModelIndex &parent )
0282 {
0283     if ( parent.isValid() ) {
0284         Q_ASSERT( parent.model() == &m_folderFilterModel );
0285     }
0286
0287     if ( name.isEmpty() ) {
0288         QModelIndex documentTreeIndex = m_treeModel->index( bookmarkDocument() );
0289         QModelIndex folderFilterIndex = m_folderFilterModel.mapFromSource( documentTreeIndex );
0290         Q_ASSERT( folderFilterIndex.isValid() );
0291         m_parent->foldersTreeView->setCurrentIndex( folderFilterIndex );
0292         handleFolderSelection( folderFilterIndex );
0293         return;
0294     }
0295
0296     for ( int i=0; i < m_folderFilterModel.rowCount( parent ); ++i ) {
0297         QModelIndex childIndex = m_folderFilterModel.index( i, 0, parent );
0298         if ( childIndex.data().toString() == name
0299             && m_selectedFolder != childIndex ) {
0300             m_parent->foldersTreeView->setCurrentIndex( childIndex );
0301             handleFolderSelection( childIndex );
0302             return;
0303         }
0304         if ( m_folderFilterModel.hasChildren( childIndex ) ) {
0305             selectFolder( name, childIndex );
0306         }
0307     }
0308 }
0309
0310 QModelIndex BookmarkManagerDialogPrivate::folderTreeIndex( const QModelIndex &index ) const
0311 {
0312     Q_ASSERT( index.isValid() );
0313     Q_ASSERT( index.model() == &m_folderFilterModel );
0314     QModelIndex const treeModelIndex = m_folderFilterModel.mapToSource( index );
0315     Q_ASSERT( treeModelIndex.isValid() );
0316     Q_ASSERT( treeModelIndex.model() == m_treeModel );
0317     return treeModelIndex;
0318 }
0319
0320 GeoDataContainer *BookmarkManagerDialogPrivate::selectedFolder()
0321 {
0322     if( m_selectedFolder.isValid() ) {
0323         GeoDataObject* object = qvariant_cast<GeoDataObject*>( m_selectedFolder.data( MarblePlacemarkModel::ObjectPointerRole ) );
0324         Q_ASSERT( object );
0325         GeoDataContainer* container = dynamic_cast<GeoDataContainer*>( object );
0326         Q_ASSERT( container );
0327         return container;
0328     } else {
0329         return bookmarkDocument();
0330     }
0331 }
0332
0333 void BookmarkManagerDialogPrivate::initializeFoldersView( GeoDataTreeModel* treeModel )
0334 {
0335     m_folderFilterModel.setFilterKeyColumn( 1 );
0336     const QString regexp = QLatin1String(GeoDataTypes::GeoDataFolderType) + QLatin1Char('|') + QLatin1String(GeoDataTypes::GeoDataDocumentType);
0337     m_folderFilterModel.setFilterRegExp( regexp );
0338     m_folderFilterModel.setSourceModel( treeModel );
0339
0340     m_parent->foldersTreeView->setModel( &m_folderFilterModel );
0341     m_parent->foldersTreeView->setEditTriggers( QAbstractItemView::NoEditTriggers );
0342     m_parent->foldersTreeView->setHeaderHidden( true );
0343     for ( int i=1; i<m_treeModel->columnCount(); ++i ) {
0344         m_parent->foldersTreeView->hideColumn( i );
0345     }
0346     m_parent->foldersTreeView->setRootIndex( m_folderFilterModel.mapFromSource(
0347                                                  m_treeModel->index( bookmarkDocument() )));
0348
0349     m_parent->connect( m_parent->foldersTreeView,
0350             SIGNAL(clicked(QModelIndex)),
0351             m_parent, SLOT(handleFolderSelection(QModelIndex)) );
0352     m_parent->connect( m_parent->foldersTreeView->selectionModel(),
0353                       SIGNAL(selectionChanged(QItemSelection,QItemSelection)),
0354                       m_parent, SLOT(updateButtonState()) );
0355     m_parent->connect( m_parent->renameFolderButton, SIGNAL(clicked(bool)),
0356                        m_parent, SLOT(renameFolder()) );
0357     m_parent->connect( m_parent->newFolderButton, SIGNAL(clicked(bool)),
0358                        m_parent, SLOT(addNewFolder()) );
0359     m_parent->connect( m_parent->removeFolderButton, SIGNAL(clicked(bool)),
0360                        m_parent, SLOT(deleteFolder()) );
0361 }
0362
0363 void BookmarkManagerDialogPrivate::initializeBookmarksView( GeoDataTreeModel* treeModel )
0364 {
0365     m_branchFilterModel.setSourceModel( treeModel );
0366
0367     m_parent->bookmarksListView->setModel( &m_branchFilterModel );
0368     m_parent->bookmarksListView->setEditTriggers( QAbstractItemView::NoEditTriggers );
0369
0370     m_parent->connect( m_parent->bookmarksListView->selectionModel(),
0371                       SIGNAL(selectionChanged(QItemSelection,QItemSelection)),
0372                       m_parent, SLOT(updateButtonState()) );
0373     m_parent->connect( m_parent->editBookmarkButton, SIGNAL(clicked(bool)),
0374                        m_parent, SLOT(editBookmark()) );
0375     m_parent->connect( m_parent->removeBookmarkButton, SIGNAL(clicked(bool)),
0376                        m_parent, SLOT(deleteBookmark()) );
0377 }
0378
0379 BookmarkManagerDialog::BookmarkManagerDialog( MarbleModel* model, QWidget *parent )
0380     : QDialog( parent ),
0381       d( new BookmarkManagerDialogPrivate( this, model ) )
0382 {
0383     setupUi( this );
0384     bool const smallScreen = MarbleGlobal::getInstance()->profiles() & MarbleGlobal::SmallScreen;
0385     importButton->setVisible( !smallScreen );
0386     exportButton->setVisible( !smallScreen );
0387     foldersLabel->setVisible( !smallScreen );
0388     bookmarkLabel->setVisible( !smallScreen );
0389
0390     d->initializeFoldersView( d->m_treeModel );
0391     d->initializeBookmarksView( d->m_treeModel );
0392     d->updateButtonState();
0393
0394     connect( this, SIGNAL(accepted()), SLOT(saveBookmarks()) );
0395     connect( this, SIGNAL(rejected()), SLOT(discardChanges()) );
0396     connect( exportButton, SIGNAL(clicked()), this, SLOT(exportBookmarks()) );
0397     connect( importButton, SIGNAL(clicked()), this, SLOT(importBookmarks()) );
0398
0399     d->selectFolder();
0400 }
0401
0402 BookmarkManagerDialog::~BookmarkManagerDialog()
0403 {
0404     delete d;
0405 }
0406
0407 void BookmarkManagerDialog::saveBookmarks()
0408 {
0409     d->m_manager->updateBookmarkFile();
0410 }
0411
0412 void BookmarkManagerDialog::exportBookmarks()
0413 {
0414     QString fileName = QFileDialog::getSaveFileName( this, tr( "Export Bookmarks" ), // krazy:exclude=qclasses
0415                        QDir::homePath(), tr( "KML files (*.kml)" ) );
0416
0417     if ( !fileName.isEmpty() ) {
0418         if (!GeoDataDocumentWriter::write(fileName, *d->bookmarkDocument())) {
0419             mDebug() << "Could not write the bookmarks file" << fileName;
0420             QString const text = tr( "Unable to save bookmarks. Please check that the file is writable." );
0421             QMessageBox::warning(this, tr("Bookmark Export"), text);
0422         }
0423     }
0424 }
0425
0426 void BookmarkManagerDialog::importBookmarks()
0427 {
0428     QString const file = QFileDialog::getOpenFileName(this, tr("Import Bookmarks"),
0429                             QDir::homePath(), tr( "KML Files (*.kml)" ) );
0430     if ( file.isEmpty() ) {
0431         return;
0432     }
0433
0434     GeoDataDocument *import = BookmarkManager::openFile( file );
0435     if ( !import ) {
0436         QString const text = tr( "The file %1 cannot be opened as a KML file." ).arg( file );
0437         QMessageBox::warning(this, tr( "Bookmark Import"), text);
0438         return;
0439     }
0440     GeoDataDocument *current = d->bookmarkDocument();
0441
0442     bool skipAll = false;
0443     bool replaceAll = false;
0444     d->importBookmarksRecursively(import, current, skipAll, replaceAll);
0445
0446     d->selectFolder();
0447 }
0448
0449 void BookmarkManagerDialogPrivate::importBookmarksRecursively( GeoDataContainer *source, GeoDataContainer *destination, bool &replaceAll, bool &skipAll )
0450 {
0451     for( GeoDataFolder *newFolder: source->folderList() ) {
0452         GeoDataFolder *existingFolder = m_manager->addNewBookmarkFolder(destination, newFolder->name());
0453         importBookmarksRecursively(newFolder, existingFolder, skipAll, replaceAll);
0454         for( GeoDataPlacemark* newPlacemark: newFolder->placemarkList() ) {
0455             bool added = skipAll;
0456
0457             GeoDataCoordinates newCoordinate = newPlacemark->coordinate();
0458             GeoDataPlacemark *existingPlacemark = m_manager->bookmarkAt( m_manager->document(), newCoordinate );
0459             if ( existingPlacemark ) {
0460                 if ( skipAll ) {
0461                     continue;
0462                 }
0463
0464                 // Avoid message boxes for equal bookmarks, just skip them
0465                 if ( existingPlacemark->name() == newPlacemark->name() &&
0466                     existingPlacemark->description() == newPlacemark->description() ) {
0467                     continue;
0468                 }
0469
0470                 QPointer<QMessageBox> messageBox = new QMessageBox( m_parent );
0471                 QString const intro = tr( "The file contains a bookmark that already exists among your Bookmarks." );
0472                 QString const newBookmark = tr( "Imported bookmark" );
0473                 QString const existingBookmark = tr( "Existing bookmark" );
0474                 QString const question = tr( "Do you want to replace the existing bookmark with the imported one?" );
0475                 QString html = QLatin1String("<p>%1</p><table><tr><td>%2</td><td><b>%3 / %4</b></td></tr>"
0476                                                 "<tr><td>%5</td><td><b>%6 / %7</b></td></tr></table><p>%8</p>");
0477                 html = html.arg( intro, existingBookmark, existingFolder->name(),
0478                                  existingPlacemark->name(), newBookmark, newFolder->name(),
0479                                  newPlacemark->name(), question );
0480                 messageBox->setText( html );
0481
0482                 QAbstractButton *replaceButton    = messageBox->addButton(tr( "Replace" ),     QMessageBox::ActionRole );
0483                 QAbstractButton *replaceAllButton = messageBox->addButton(tr( "Replace All" ), QMessageBox::ActionRole );
0484                 QAbstractButton *skipButton       = messageBox->addButton(tr( "Skip" ),        QMessageBox::ActionRole );
0485                 QAbstractButton *skipAllButton    = messageBox->addButton(tr( "Skip All" ),    QMessageBox::ActionRole );
0486                                                     messageBox->addButton( QMessageBox::Cancel );
0487                 messageBox->setIcon( QMessageBox::Question );
0488
0489                 if ( !replaceAll ) {
0490                     messageBox->exec();
0491                 }
0492                 if ( messageBox->clickedButton() == replaceAllButton ) {
0493                     replaceAll = true;
0494                 } else if ( messageBox->clickedButton() == skipAllButton ) {
0495                     skipAll = true;
0496                     added = true;
0497                 } else if ( messageBox->clickedButton() == skipButton ) {
0498                     delete messageBox;
0499                     continue;
0500                 } else if ( messageBox->clickedButton() != replaceButton ) {
0501                     delete messageBox;
0502                     return;
0503                 }
0504
0505                 if ( messageBox->clickedButton() == replaceButton || replaceAll ) {
0506                     m_manager->removeBookmark( existingPlacemark );
0507                     m_manager->addBookmark( existingFolder, *newPlacemark );
0508
0509                     mDebug() << "Placemark " << newPlacemark->name() << " replaces " << existingPlacemark->name();
0510                     delete messageBox;
0511                     break;
0512                 }
0513                 delete messageBox;
0514             }
0515
0516             if ( !added ) {
0517                 m_manager->addBookmark( existingFolder, *newPlacemark );
0518             }
0519         }
0520     }
0521 }
0522
0523 GeoDataDocument* BookmarkManagerDialogPrivate::bookmarkDocument()
0524 {
0525     return m_manager->document();
0526 }
0527
0528 void BookmarkManagerDialog::setButtonBoxVisible( bool visible )
0529 {
0530     buttonBox->setVisible( visible );
0531     if ( !visible ) {
0532         disconnect( this, SIGNAL(rejected()), this, SLOT(discardChanges()) );
0533         connect( this, SIGNAL(rejected()), SLOT(saveBookmarks()) );
0534     }
0535 }
0536
0537 }
0538
0539 #include "moc_BookmarkManagerDialog.cpp"