diff --git a/src/CMakeLists.txt b/src/CMakeLists.txt index 6e4d9f9e8f..518c8b7d2f 100644 --- a/src/CMakeLists.txt +++ b/src/CMakeLists.txt @@ -172,6 +172,7 @@ set(dolphin_SRCS dolphinviewcontainer.cpp dolphincontextmenu.cpp dolphinrecenttabsmenu.cpp + dolphintabpage.cpp filterbar/filterbar.cpp main.cpp panels/information/filemetadataconfigurationdialog.cpp diff --git a/src/dolphinmainwindow.cpp b/src/dolphinmainwindow.cpp index c60951d2c6..d9fe6458d7 100644 --- a/src/dolphinmainwindow.cpp +++ b/src/dolphinmainwindow.cpp @@ -27,6 +27,7 @@ #include "dolphinnewfilemenu.h" #include "dolphinrecenttabsmenu.h" #include "dolphinviewcontainer.h" +#include "dolphintabpage.h" #include "panels/folders/folderspanel.h" #include "panels/places/placespanel.h" #include "panels/information/informationpanel.h" @@ -86,7 +87,6 @@ #include #include #include -#include namespace { // Used for GeneralSettings::version() to determine whether @@ -100,7 +100,7 @@ DolphinMainWindow::DolphinMainWindow() : m_tabBar(0), m_activeViewContainer(0), m_centralWidgetLayout(0), - m_tabIndex(0), + m_tabIndex(-1), m_viewTab(), m_actionHandler(0), m_remoteEncoding(0), @@ -111,10 +111,6 @@ DolphinMainWindow::DolphinMainWindow() : { setObjectName("Dolphin#"); - m_viewTab.append(ViewTab()); - ViewTab& viewTab = m_viewTab[m_tabIndex]; - viewTab.wasActive = true; // The first opened tab is automatically active - connect(&DolphinNewFileMenuObserver::instance(), SIGNAL(errorMessage(QString)), this, SLOT(showErrorMessage(QString))); @@ -138,25 +134,12 @@ DolphinMainWindow::DolphinMainWindow() : setAcceptDrops(true); - viewTab.splitter = new QSplitter(this); - viewTab.splitter->setChildrenCollapsible(false); - setupActions(); - const KUrl homeUrl(generalSettings->homeUrl()); - setUrlAsCaption(homeUrl); m_actionHandler = new DolphinViewActionHandler(actionCollection(), this); connect(m_actionHandler, SIGNAL(actionBeingHandled()), SLOT(clearStatusBar())); connect(m_actionHandler, SIGNAL(createDirectory()), SLOT(createDirectory())); - viewTab.primaryView = createViewContainer(homeUrl, viewTab.splitter); - - m_activeViewContainer = viewTab.primaryView; - connectViewSignals(m_activeViewContainer); - DolphinView* view = m_activeViewContainer->view(); - m_activeViewContainer->show(); - m_actionHandler->setCurrentView(view); - m_remoteEncoding = new DolphinRemoteEncoding(this, m_actionHandler); connect(this, SIGNAL(urlChanged(KUrl)), m_remoteEncoding, SLOT(slotAboutToOpenUrl())); @@ -182,17 +165,16 @@ DolphinMainWindow::DolphinMainWindow() : this, SLOT(tabDropEvent(int,QDropEvent*))); m_tabBar->blockSignals(true); // signals get unblocked after at least 2 tabs are open + m_tabBar->hide(); QWidget* centralWidget = new QWidget(this); m_centralWidgetLayout = new QVBoxLayout(centralWidget); m_centralWidgetLayout->setSpacing(0); m_centralWidgetLayout->setMargin(0); m_centralWidgetLayout->addWidget(m_tabBar); - m_centralWidgetLayout->addWidget(viewTab.splitter, 1); setCentralWidget(centralWidget); setupDockWidgets(); - emit urlChanged(homeUrl); setupGUI(Keys | Save | Create | ToolBar); stateChanged("new_file"); @@ -201,14 +183,6 @@ DolphinMainWindow::DolphinMainWindow() : connect(clipboard, SIGNAL(dataChanged()), this, SLOT(updatePasteAction())); - if (generalSettings->splitView()) { - toggleSplitView(); - } - updateEditActions(); - updatePasteAction(); - updateViewActions(); - updateGoActions(); - QAction* showFilterBarAction = actionCollection()->action("show_filter_bar"); showFilterBarAction->setChecked(generalSettings->filterBar()); @@ -224,6 +198,9 @@ DolphinMainWindow::DolphinMainWindow() : if (!showMenu) { createControlButton(); } + + const KUrl homeUrl(generalSettings->homeUrl()); + openNewActivatedTab(homeUrl); } DolphinMainWindow::~DolphinMainWindow() @@ -249,13 +226,12 @@ void DolphinMainWindow::openDirectories(const QList& dirs) // always show two directories within one tab. QList::const_iterator it = dirs.constBegin(); while (it != dirs.constEnd()) { - openNewTab(*it); - ++it; - + const KUrl& primaryUrl = *(it++); if (hasSplitView && (it != dirs.constEnd())) { - const int tabIndex = m_viewTab.count() - 1; - m_viewTab[tabIndex].secondaryView->setUrl(*it); - ++it; + const KUrl& secondaryUrl = *(it++); + openNewTab(primaryUrl, secondaryUrl); + } else { + openNewTab(primaryUrl); } } @@ -287,14 +263,9 @@ void DolphinMainWindow::openFiles(const QList& files) // Select the files. Although the files can be split between several // tabs, there is no need to split 'files' accordingly, as // the DolphinView will just ignore invalid selections. - const int tabCount = m_viewTab.count(); - for (int i = 0; i < tabCount; ++i) { - m_viewTab[i].primaryView->view()->markUrlsAsSelected(files); - m_viewTab[i].primaryView->view()->markUrlAsCurrent(files.at(0)); - if (m_viewTab[i].secondaryView) { - m_viewTab[i].secondaryView->view()->markUrlsAsSelected(files); - m_viewTab[i].secondaryView->view()->markUrlAsCurrent(files.at(0)); - } + foreach (DolphinTabPage* tabPage, m_viewTab) { + tabPage->markUrlsAsSelected(files); + tabPage->markUrlAsCurrent(files.first()); } } @@ -349,11 +320,11 @@ void DolphinMainWindow::changeUrl(const KUrl& url) updateViewActions(); updateGoActions(); setUrlAsCaption(url); - if (m_viewTab.count() > 1) { - m_tabBar->setTabText(m_tabIndex, squeezedText(tabName(m_activeViewContainer->url()))); - } + const QString iconName = KMimeType::iconNameForUrl(url); m_tabBar->setTabIcon(m_tabIndex, KIcon(iconName)); + m_tabBar->setTabText(m_tabIndex, squeezedText(tabName(view->url()))); + emit urlChanged(url); } } @@ -376,11 +347,7 @@ void DolphinMainWindow::slotSelectionChanged(const KFileItemList& selection) { updateEditActions(); - Q_ASSERT(m_viewTab[m_tabIndex].primaryView); - int selectedUrlsCount = m_viewTab[m_tabIndex].primaryView->view()->selectedItemsCount(); - if (m_viewTab[m_tabIndex].secondaryView) { - selectedUrlsCount += m_viewTab[m_tabIndex].secondaryView->view()->selectedItemsCount(); - } + const int selectedUrlsCount = m_viewTab.at(m_tabIndex)->selectedItemsCount(); QAction* compareFilesAction = actionCollection()->action("compare_files"); if (selectedUrlsCount == 2) { @@ -445,41 +412,41 @@ void DolphinMainWindow::openNewTab() } } -void DolphinMainWindow::openNewTab(const KUrl& url) +void DolphinMainWindow::openNewTab(const KUrl& primaryUrl, const KUrl& secondaryUrl) { QWidget* focusWidget = QApplication::focusWidget(); - if (m_viewTab.count() == 1) { - // Only one view is open currently and hence no tab is shown at - // all. Before creating a tab for 'url', provide a tab for the current URL. - const KUrl currentUrl = m_activeViewContainer->url(); - m_tabBar->addTab(KIcon(KMimeType::iconNameForUrl(currentUrl)), - squeezedText(tabName(currentUrl))); - m_tabBar->blockSignals(false); + DolphinTabPage* tabPage = new DolphinTabPage(primaryUrl, secondaryUrl, this); + m_viewTab.append(tabPage); + + connect(tabPage, SIGNAL(activeViewChanged()), + this, SLOT(activeViewChanged())); + + // The places-selector from the URL navigator should only be shown + // if the places dock is invisible + QDockWidget* placesDock = findChild("placesDock"); + const bool placesSelectorVisible = !placesDock || !placesDock->isVisible(); + tabPage->setPlacesSelectorVisible(placesSelectorVisible); + + DolphinViewContainer* primaryContainer = tabPage->primaryViewContainer(); + connectViewSignals(primaryContainer); + + if (tabPage->splitViewEnabled()) { + DolphinViewContainer* secondaryContainer = tabPage->secondaryViewContainer(); + connectViewSignals(secondaryContainer); } - m_tabBar->addTab(KIcon(KMimeType::iconNameForUrl(url)), - squeezedText(tabName(url))); + tabPage->hide(); - ViewTab viewTab; - viewTab.splitter = new QSplitter(this); - viewTab.splitter->setChildrenCollapsible(false); - viewTab.primaryView = createViewContainer(url, viewTab.splitter); - viewTab.primaryView->setActive(false); - connectViewSignals(viewTab.primaryView); + m_tabBar->addTab(KIcon(KMimeType::iconNameForUrl(primaryUrl)), + squeezedText(tabName(primaryUrl))); - m_viewTab.append(viewTab); - - actionCollection()->action("close_tab")->setEnabled(true); - actionCollection()->action("activate_prev_tab")->setEnabled(true); - actionCollection()->action("activate_next_tab")->setEnabled(true); - - // Provide a split view, if the startup settings are set this way - if (GeneralSettings::splitView()) { - const int newTabIndex = m_viewTab.count() - 1; - createSecondaryView(newTabIndex); - m_viewTab[newTabIndex].secondaryView->setActive(true); - m_viewTab[newTabIndex].isPrimaryViewActive = false; + if (m_viewTab.count() > 1) { + actionCollection()->action("close_tab")->setEnabled(true); + actionCollection()->action("activate_prev_tab")->setEnabled(true); + actionCollection()->action("activate_next_tab")->setEnabled(true); + m_tabBar->show(); + m_tabBar->blockSignals(false); } if (focusWidget) { @@ -489,17 +456,17 @@ void DolphinMainWindow::openNewTab(const KUrl& url) } } -void DolphinMainWindow::openNewActivatedTab(const KUrl& url) +void DolphinMainWindow::openNewActivatedTab(const KUrl& primaryUrl, const KUrl& secondaryUrl) { - openNewTab(url); - m_tabBar->setCurrentIndex(m_viewTab.count() - 1); + openNewTab(primaryUrl, secondaryUrl); + setActiveTab(m_viewTab.count() - 1); } void DolphinMainWindow::activateNextTab() { if (m_viewTab.count() >= 2) { const int tabIndex = (m_tabBar->currentIndex() + 1) % m_tabBar->count(); - m_tabBar->setCurrentIndex(tabIndex); + setActiveTab(tabIndex); } } @@ -510,7 +477,7 @@ void DolphinMainWindow::activatePrevTab() if (tabIndex == -1) { tabIndex = m_tabBar->count() - 1; } - m_tabBar->setCurrentIndex(tabIndex); + setActiveTab(tabIndex); } } @@ -546,21 +513,6 @@ void DolphinMainWindow::openInNewWindow() } } -void DolphinMainWindow::toggleActiveView() -{ - if (!m_viewTab[m_tabIndex].secondaryView) { - // only one view is available - return; - } - - Q_ASSERT(m_activeViewContainer); - Q_ASSERT(m_viewTab[m_tabIndex].primaryView); - - DolphinViewContainer* left = m_viewTab[m_tabIndex].primaryView; - DolphinViewContainer* right = m_viewTab[m_tabIndex].secondaryView; - setActiveViewContainer(m_activeViewContainer == right ? left : right); -} - void DolphinMainWindow::showEvent(QShowEvent* event) { KXmlGuiWindow::showEvent(event); @@ -634,17 +586,8 @@ void DolphinMainWindow::saveProperties(KConfigGroup& group) group.writeEntry("Active Tab Index", m_tabBar->currentIndex()); for (int i = 0; i < tabCount; ++i) { - const DolphinViewContainer* cont = m_viewTab[i].primaryView; - group.writeEntry(tabProperty("Primary URL", i), cont->url().url()); - group.writeEntry(tabProperty("Primary Editable", i), - cont->urlNavigator()->isUrlEditable()); - - cont = m_viewTab[i].secondaryView; - if (cont) { - group.writeEntry(tabProperty("Secondary URL", i), cont->url().url()); - group.writeEntry(tabProperty("Secondary Editable", i), - cont->urlNavigator()->isUrlEditable()); - } + const DolphinTabPage* tabPage = m_viewTab.at(i); + group.writeEntry("Tab " % QString::number(i), tabPage->saveState()); } } @@ -652,38 +595,9 @@ void DolphinMainWindow::readProperties(const KConfigGroup& group) { const int tabCount = group.readEntry("Tab Count", 1); for (int i = 0; i < tabCount; ++i) { - DolphinViewContainer* cont = m_viewTab[i].primaryView; - - cont->setUrl(group.readEntry(tabProperty("Primary URL", i))); - const bool editable = group.readEntry(tabProperty("Primary Editable", i), false); - cont->urlNavigator()->setUrlEditable(editable); - - cont = m_viewTab[i].secondaryView; - const QString secondaryUrl = group.readEntry(tabProperty("Secondary URL", i)); - if (!secondaryUrl.isEmpty()) { - if (!cont) { - // a secondary view should be shown, but no one is available - // currently -> create a new view - toggleSplitView(); - cont = m_viewTab[i].secondaryView; - Q_ASSERT(cont); - } - - // The right view must be activated before the URL is set. Changing - // the URL in the right view will emit the right URL navigator's - // urlChanged(KUrl) signal, which is connected to the changeUrl(KUrl) - // slot. That slot will change the URL in the left view if it is still - // active. See https://bugs.kde.org/show_bug.cgi?id=330047. - setActiveViewContainer(cont); - - cont->setUrl(secondaryUrl); - const bool editable = group.readEntry(tabProperty("Secondary Editable", i), false); - cont->urlNavigator()->setUrlEditable(editable); - } else if (cont) { - // no secondary view should be shown, but the default setting shows - // one already -> close the view - toggleSplitView(); - } + const QByteArray state = group.readEntry("Tab " % QString::number(i), QByteArray()); + DolphinTabPage* tabPage = m_viewTab.at(i); + tabPage->restoreState(state); // openNewTab() needs to be called only tabCount - 1 times if (i != tabCount - 1) { @@ -796,28 +710,11 @@ void DolphinMainWindow::invertSelection() void DolphinMainWindow::toggleSplitView() { - if (!m_viewTab[m_tabIndex].secondaryView) { - createSecondaryView(m_tabIndex); - setActiveViewContainer(m_viewTab[m_tabIndex].secondaryView); - } else if (m_activeViewContainer == m_viewTab[m_tabIndex].secondaryView) { - // remove secondary view - m_viewTab[m_tabIndex].secondaryView->close(); - m_viewTab[m_tabIndex].secondaryView->deleteLater(); - m_viewTab[m_tabIndex].secondaryView = 0; + DolphinTabPage* tabPage = m_viewTab.at(m_tabIndex); + tabPage->setSplitViewEnabled(!tabPage->splitViewEnabled()); - setActiveViewContainer(m_viewTab[m_tabIndex].primaryView); - } else { - // The primary view is active and should be closed. Hence from a users point of view - // the content of the secondary view should be moved to the primary view. - // From an implementation point of view it is more efficient to close - // the primary view and exchange the internal pointers afterwards. - - m_viewTab[m_tabIndex].primaryView->close(); - m_viewTab[m_tabIndex].primaryView->deleteLater(); - m_viewTab[m_tabIndex].primaryView = m_viewTab[m_tabIndex].secondaryView; - m_viewTab[m_tabIndex].secondaryView = 0; - - setActiveViewContainer(m_viewTab[m_tabIndex].primaryView); + if (tabPage->splitViewEnabled()) { + connectViewSignals(tabPage->secondaryViewContainer()); } updateViewActions(); @@ -884,14 +781,8 @@ void DolphinMainWindow::togglePanelLockState() void DolphinMainWindow::slotPlacesPanelVisibilityChanged(bool visible) { - const int tabCount = m_viewTab.count(); - for (int i = 0; i < tabCount; ++i) { - ViewTab& tab = m_viewTab[i]; - Q_ASSERT(tab.primaryView); - tab.primaryView->urlNavigator()->setPlacesSelectorVisible(!visible); - if (tab.secondaryView) { - tab.secondaryView->urlNavigator()->setPlacesSelectorVisible(!visible); - } + foreach (DolphinTabPage* tabPage, m_viewTab) { + tabPage->setPlacesSelectorVisible(visible); } } @@ -960,15 +851,7 @@ void DolphinMainWindow::goHome(Qt::MouseButtons buttons) void DolphinMainWindow::compareFiles() { - const DolphinViewContainer* primaryViewContainer = m_viewTab[m_tabIndex].primaryView; - Q_ASSERT(primaryViewContainer); - KFileItemList items = primaryViewContainer->view()->selectedItems(); - - const DolphinViewContainer* secondaryViewContainer = m_viewTab[m_tabIndex].secondaryView; - if (secondaryViewContainer) { - items.append(secondaryViewContainer->view()->selectedItems()); - } - + const KFileItemList items = m_viewTab.at(m_tabIndex)->selectedItems(); if (items.count() != 2) { // The action is disabled in this case, but it could have been triggered // via D-Bus, see https://bugs.kde.org/show_bug.cgi?id=325517 @@ -1038,42 +921,23 @@ void DolphinMainWindow::setActiveTab(int index) return; } + m_tabBar->setCurrentIndex(index); + // hide current tab content - ViewTab& hiddenTab = m_viewTab[m_tabIndex]; - hiddenTab.isPrimaryViewActive = hiddenTab.primaryView->isActive(); - hiddenTab.primaryView->setActive(false); - if (hiddenTab.secondaryView) { - hiddenTab.secondaryView->setActive(false); + if (m_tabIndex >= 0) { + DolphinTabPage* hiddenTabPage = m_viewTab.at(m_tabIndex); + hiddenTabPage->hide(); + m_centralWidgetLayout->removeWidget(hiddenTabPage); } - QSplitter* splitter = m_viewTab[m_tabIndex].splitter; - splitter->hide(); - m_centralWidgetLayout->removeWidget(splitter); // show active tab content m_tabIndex = index; - ViewTab& viewTab = m_viewTab[index]; - m_centralWidgetLayout->addWidget(viewTab.splitter, 1); - viewTab.primaryView->show(); - if (viewTab.secondaryView) { - viewTab.secondaryView->show(); - } - viewTab.splitter->show(); + DolphinTabPage* tabPage = m_viewTab.at(index); + m_centralWidgetLayout->addWidget(tabPage, 1); + tabPage->show(); - if (!viewTab.wasActive) { - viewTab.wasActive = true; - - // If the tab has not been activated yet the size of the KItemListView is - // undefined and results in an unwanted animation. To prevent this a - // reloading of the directory gets triggered. - viewTab.primaryView->view()->reload(); - if (viewTab.secondaryView) { - viewTab.secondaryView->view()->reload(); - } - } - - setActiveViewContainer(viewTab.isPrimaryViewActive ? viewTab.primaryView : - viewTab.secondaryView); + setActiveViewContainer(tabPage->activeViewContainer()); } void DolphinMainWindow::closeTab() @@ -1096,17 +960,18 @@ void DolphinMainWindow::closeTab(int index) m_tabBar->setCurrentIndex((index > 0) ? index - 1 : 1); } - const KUrl primaryUrl(m_viewTab[index].primaryView->url()); - const KUrl secondaryUrl(m_viewTab[index].secondaryView ? m_viewTab[index].secondaryView->url() : KUrl()); - emit rememberClosedTab(primaryUrl, secondaryUrl); + DolphinTabPage* tabPage = m_viewTab.at(index); + + if (tabPage->splitViewEnabled()) { + emit rememberClosedTab(tabPage->primaryViewContainer()->url(), + tabPage->secondaryViewContainer()->url()); + } else { + emit rememberClosedTab(tabPage->primaryViewContainer()->url(), KUrl()); + } // delete tab - m_viewTab[index].primaryView->deleteLater(); - if (m_viewTab[index].secondaryView) { - m_viewTab[index].secondaryView->deleteLater(); - } - m_viewTab[index].splitter->deleteLater(); - m_viewTab.erase(m_viewTab.begin() + index); + m_viewTab.removeAt(index); + tabPage->deleteLater(); m_tabBar->blockSignals(true); m_tabBar->removeTab(index); @@ -1118,11 +983,11 @@ void DolphinMainWindow::closeTab(int index) // if only one tab is left, also remove the tab entry so that // closing the last tab is not possible - if (m_viewTab.count() == 1) { - m_tabBar->removeTab(0); + if (m_viewTab.count() < 2) { actionCollection()->action("close_tab")->setEnabled(false); actionCollection()->action("activate_prev_tab")->setEnabled(false); actionCollection()->action("activate_next_tab")->setEnabled(false); + m_tabBar->hide(); } else { m_tabBar->blockSignals(false); } @@ -1143,22 +1008,18 @@ void DolphinMainWindow::openTabContextMenu(int index, const QPoint& pos) closeTabAction->setShortcut(actionCollection()->action("close_tab")->shortcut()); QAction* selectedAction = menu.exec(pos); if (selectedAction == newTabAction) { - const ViewTab& tab = m_viewTab[index]; - Q_ASSERT(tab.primaryView); - const KUrl url = tab.secondaryView && tab.secondaryView->isActive() ? - tab.secondaryView->url() : tab.primaryView->url(); + const KUrl url = m_viewTab.at(index)->activeViewContainer()->url(); openNewTab(url); m_tabBar->setCurrentIndex(m_viewTab.count() - 1); } else if (selectedAction == detachTabAction) { const QString separator(QLatin1Char(' ')); QString command = QLatin1String("dolphin"); - const ViewTab& tab = m_viewTab[index]; - Q_ASSERT(tab.primaryView); + const DolphinTabPage* tabPage = m_viewTab.at(index); - command += separator + tab.primaryView->url().url(); - if (tab.secondaryView) { - command += separator + tab.secondaryView->url().url(); + command += separator + tabPage->primaryViewContainer()->url().url(); + if (tabPage->splitViewEnabled()) { + command += separator + tabPage->secondaryViewContainer()->url().url(); command += separator + QLatin1String("-split"); } @@ -1226,9 +1087,8 @@ void DolphinMainWindow::tabDropEvent(int tab, QDropEvent* event) { const KUrl::List urls = KUrl::List::fromMimeData(event->mimeData()); if (!urls.isEmpty() && tab != -1) { - const ViewTab& viewTab = m_viewTab[tab]; - const DolphinView* view = viewTab.isPrimaryViewActive ? viewTab.primaryView->view() - : viewTab.secondaryView->view(); + const DolphinView* view = m_viewTab.at(tab)->activeViewContainer()->view(); + QString error; DragAndDropHelper::dropUrls(view->rootItem(), view->url(), event, error); if (!error.isEmpty()) { @@ -1396,37 +1256,22 @@ void DolphinMainWindow::slotPlaceActivated(const KUrl& url) } } -void DolphinMainWindow::restoreClosedTab(const KUrl& primaryUrl, const KUrl& secondaryUrl) +void DolphinMainWindow::activeViewChanged() { - openNewActivatedTab(primaryUrl); - - if (!secondaryUrl.isEmpty() && secondaryUrl.isValid()) { - const int index = m_tabBar->currentIndex(); - createSecondaryView(index); - setActiveViewContainer(m_viewTab[index].secondaryView); - m_viewTab[index].secondaryView->setUrl(secondaryUrl); - } + const DolphinTabPage* tabPage = m_viewTab.at(m_tabIndex); + setActiveViewContainer(tabPage->activeViewContainer()); } void DolphinMainWindow::setActiveViewContainer(DolphinViewContainer* viewContainer) { Q_ASSERT(viewContainer); - Q_ASSERT((viewContainer == m_viewTab[m_tabIndex].primaryView) || - (viewContainer == m_viewTab[m_tabIndex].secondaryView)); + Q_ASSERT((viewContainer == m_viewTab.at(m_tabIndex)->primaryViewContainer()) || + (viewContainer == m_viewTab.at(m_tabIndex)->secondaryViewContainer())); if (m_activeViewContainer == viewContainer) { return; } - m_activeViewContainer->setActive(false); m_activeViewContainer = viewContainer; - - // Activating the view container might trigger a recursive setActiveViewContainer() call - // inside DolphinMainWindow::toggleActiveView() when having a split view. Temporary - // disconnect the activated() signal in this case: - disconnect(m_activeViewContainer->view(), SIGNAL(activated()), this, SLOT(toggleActiveView())); - m_activeViewContainer->setActive(true); - connect(m_activeViewContainer->view(), SIGNAL(activated()), this, SLOT(toggleActiveView())); - m_actionHandler->setCurrentView(viewContainer->view()); updateHistory(); @@ -1437,26 +1282,12 @@ void DolphinMainWindow::setActiveViewContainer(DolphinViewContainer* viewContain const KUrl url = m_activeViewContainer->url(); setUrlAsCaption(url); - if (m_viewTab.count() > 1) { - m_tabBar->setTabText(m_tabIndex, tabName(url)); - m_tabBar->setTabIcon(m_tabIndex, KIcon(KMimeType::iconNameForUrl(url))); - } + m_tabBar->setTabText(m_tabIndex, squeezedText(tabName(url))); + m_tabBar->setTabIcon(m_tabIndex, KIcon(KMimeType::iconNameForUrl(url))); emit urlChanged(url); } -DolphinViewContainer* DolphinMainWindow::createViewContainer(const KUrl& url, QWidget* parent) -{ - DolphinViewContainer* container = new DolphinViewContainer(url, parent); - - // The places-selector from the URL navigator should only be shown - // if the places dock is invisible - QDockWidget* placesDock = findChild("placesDock"); - container->urlNavigator()->setPlacesSelectorVisible(!placesDock || !placesDock->isVisible()); - - return container; -} - void DolphinMainWindow::setupActions() { // setup 'File' menu @@ -1524,7 +1355,6 @@ void DolphinMainWindow::setupActions() KAction* split = actionCollection()->addAction("split_view"); split->setShortcut(Qt::Key_F3); - updateSplitAction(); connect(split, SIGNAL(triggered()), this, SLOT(toggleSplitView())); KAction* reload = actionCollection()->addAction("reload"); @@ -1561,7 +1391,7 @@ void DolphinMainWindow::setupActions() connect(this, SIGNAL(rememberClosedTab(KUrl,KUrl)), recentTabsMenu, SLOT(rememberClosedTab(KUrl,KUrl))); connect(recentTabsMenu, SIGNAL(restoreClosedTab(KUrl,KUrl)), - this, SLOT(restoreClosedTab(KUrl,KUrl))); + this, SLOT(openNewActivatedTab(KUrl,KUrl))); KAction* forwardAction = KStandardAction::forward(this, SLOT(goForward()), actionCollection()); connect(forwardAction, SIGNAL(triggered(Qt::MouseButtons,Qt::KeyboardModifiers)), this, SLOT(goForward(Qt::MouseButtons))); @@ -1872,33 +1702,16 @@ bool DolphinMainWindow::addActionToMenu(QAction* action, KMenu* menu) void DolphinMainWindow::refreshViews() { - Q_ASSERT(m_viewTab[m_tabIndex].primaryView); - - // remember the current active view, as because of - // the refreshing the active view might change to - // the secondary view - DolphinViewContainer* activeViewContainer = m_activeViewContainer; - - const int tabCount = m_viewTab.count(); - for (int i = 0; i < tabCount; ++i) { - m_viewTab[i].primaryView->readSettings(); - if (m_viewTab[i].secondaryView) { - m_viewTab[i].secondaryView->readSettings(); - } + foreach (DolphinTabPage* tabPage, m_viewTab) { + tabPage->refreshViews(); } - setActiveViewContainer(activeViewContainer); - if (GeneralSettings::modifiedStartupSettings()) { // The startup settings have been changed by the user (see bug #254947). // Synchronize the split-view setting with the active view: const bool splitView = GeneralSettings::splitView(); - const ViewTab& activeTab = m_viewTab[m_tabIndex]; - const bool toggle = ( splitView && !activeTab.secondaryView) - || (!splitView && activeTab.secondaryView); - if (toggle) { - toggleSplitView(); - } + m_viewTab.at(m_tabIndex)->setSplitViewEnabled(splitView); + updateSplitAction(); } emit settingsChanged(); @@ -1916,13 +1729,11 @@ void DolphinMainWindow::connectViewSignals(DolphinViewContainer* container) connect(container, SIGNAL(writeStateChanged(bool)), this, SLOT(slotWriteStateChanged(bool))); - DolphinView* view = container->view(); + const DolphinView* view = container->view(); connect(view, SIGNAL(selectionChanged(KFileItemList)), this, SLOT(slotSelectionChanged(KFileItemList))); connect(view, SIGNAL(requestItemInfo(KFileItem)), this, SLOT(slotRequestItemInfo(KFileItem))); - connect(view, SIGNAL(activated()), - this, SLOT(toggleActiveView())); connect(view, SIGNAL(tabRequested(KUrl)), this, SLOT(openNewTab(KUrl))); connect(view, SIGNAL(requestContextMenu(QPoint,KFileItem,KUrl,QList)), @@ -1950,15 +1761,16 @@ void DolphinMainWindow::connectViewSignals(DolphinViewContainer* container) void DolphinMainWindow::updateSplitAction() { QAction* splitAction = actionCollection()->action("split_view"); - if (m_viewTab[m_tabIndex].secondaryView) { - if (m_activeViewContainer == m_viewTab[m_tabIndex].secondaryView) { - splitAction->setText(i18nc("@action:intoolbar Close right view", "Close")); - splitAction->setToolTip(i18nc("@info", "Close right view")); - splitAction->setIcon(KIcon("view-right-close")); - } else { + const DolphinTabPage* tabPage = m_viewTab.at(m_tabIndex); + if (tabPage->splitViewEnabled()) { + if (tabPage->primaryViewActive()) { splitAction->setText(i18nc("@action:intoolbar Close left view", "Close")); splitAction->setToolTip(i18nc("@info", "Close left view")); splitAction->setIcon(KIcon("view-left-close")); + } else { + splitAction->setText(i18nc("@action:intoolbar Close right view", "Close")); + splitAction->setToolTip(i18nc("@info", "Close right view")); + splitAction->setIcon(KIcon("view-right-close")); } } else { splitAction->setText(i18nc("@action:intoolbar Split view", "Split")); @@ -1998,35 +1810,6 @@ bool DolphinMainWindow::isKompareInstalled() const return installed; } -void DolphinMainWindow::createSecondaryView(int tabIndex) -{ - ViewTab& viewTab = m_viewTab[tabIndex]; - - QSplitter* splitter = viewTab.splitter; - const int newWidth = (viewTab.primaryView->width() - splitter->handleWidth()) / 2; - - const DolphinView* view = viewTab.primaryView->view(); - // The final parent of the new view container will be set by adding it - // to the splitter. However, we must make sure that the DolphinMainWindow - // is a parent of the view container already when it is constructed - // because this enables the container's KFileItemModel to assign its - // dir lister to the right main window. The dir lister can then cache - // authentication data. - viewTab.secondaryView = createViewContainer(view->url(), this); - splitter->addWidget(viewTab.secondaryView); - splitter->setSizes(QList() << newWidth << newWidth); - - connectViewSignals(viewTab.secondaryView); - viewTab.secondaryView->setActive(false); - viewTab.secondaryView->resize(newWidth, viewTab.primaryView->height()); - viewTab.secondaryView->show(); -} - -QString DolphinMainWindow::tabProperty(const QString& property, int tabIndex) const -{ - return "Tab " + QString::number(tabIndex) + ' ' + property; -} - void DolphinMainWindow::setUrlAsCaption(const KUrl& url) { QString caption; diff --git a/src/dolphinmainwindow.h b/src/dolphinmainwindow.h index acf60a4f6e..7c3bff47fd 100644 --- a/src/dolphinmainwindow.h +++ b/src/dolphinmainwindow.h @@ -40,6 +40,7 @@ class DolphinApplication; class DolphinSettingsDialog; class DolphinViewContainer; class DolphinRemoteEncoding; +class DolphinTabPage; class KAction; class KFileItem; class KFileItemList; @@ -88,13 +89,6 @@ public: */ void openFiles(const QList& files); - /** - * Returns true, if the main window contains two instances - * of a view container. The active view constainer can be - * accessed by DolphinMainWindow::activeViewContainer(). - */ - bool isSplit() const; - /** * Returns the 'Create New...' sub menu which also can be shared * with other menus (e. g. a context menu). @@ -353,15 +347,16 @@ private slots: void openNewTab(); /** - * Opens a new tab in the background showing the URL \a url. + * Opens a new tab in the background showing the URL \a primaryUrl and the + * optional URL \a secondaryUrl. */ - void openNewTab(const KUrl& url); + void openNewTab(const KUrl& primaryUrl, const KUrl& secondaryUrl = KUrl()); /** - * Opens a new tab showing the URL \a url and activates - * the tab. + * Opens a new tab showing the URL \a primaryUrl and the optional URL + * \a secondaryUrl and activates the tab. */ - void openNewActivatedTab(const KUrl& url); + void openNewActivatedTab(const KUrl& primaryUrl, const KUrl& secondaryUrl = KUrl()); void activateNextTab(); @@ -377,9 +372,6 @@ private slots: */ void openInNewWindow(); - /** Toggles the active view if two views are shown within the main window. */ - void toggleActiveView(); - /** * Indicates in the statusbar that the execution of the command \a command * has been finished. @@ -474,11 +466,7 @@ private slots: */ void slotPlaceActivated(const KUrl& url); - /** - * Is called when the user wants to reopen a previously closed \a tab from - * the recent tabs menu. - */ - void restoreClosedTab(const KUrl& primaryUrl, const KUrl& secondaryUrl); + void activeViewChanged(); private: /** @@ -489,11 +477,6 @@ private: */ void setActiveViewContainer(DolphinViewContainer* view); - /** - * Creates a view container and does a default initialization. - */ - DolphinViewContainer* createViewContainer(const KUrl& url, QWidget* parent); - void setupActions(); void setupDockWidgets(); void updateEditActions(); @@ -529,17 +512,9 @@ private: /** Returns the name of the tab for the URL \a url. */ QString tabName(const KUrl& url) const; + bool isKompareInstalled() const; - void createSecondaryView(int tabIndex); - - /** - * Helper method for saveProperties() and readProperties(): Returns - * the property string for a tab with the index \a tabIndex and - * the property \a property. - */ - QString tabProperty(const QString& property, int tabIndex) const; - /** * Sets the window caption to url.fileName() if this is non-empty, * "/" if the URL is "file:///", and url.protocol() otherwise. @@ -579,18 +554,8 @@ private: QVBoxLayout* m_centralWidgetLayout; int m_id; - // Members for the tab-handling: - struct ViewTab - { - ViewTab() : isPrimaryViewActive(true), wasActive(false), primaryView(0), secondaryView(0), splitter(0) {} - bool isPrimaryViewActive; - bool wasActive; - DolphinViewContainer* primaryView; - DolphinViewContainer* secondaryView; - QSplitter* splitter; - }; int m_tabIndex; - QList m_viewTab; + QList m_viewTab; DolphinViewActionHandler* m_actionHandler; DolphinRemoteEncoding* m_remoteEncoding; @@ -608,11 +573,6 @@ inline DolphinViewContainer* DolphinMainWindow::activeViewContainer() const return m_activeViewContainer; } -inline bool DolphinMainWindow::isSplit() const -{ - return m_viewTab[m_tabIndex].secondaryView != 0; -} - inline KNewFileMenu* DolphinMainWindow::newFileMenu() const { return m_newFileMenu; diff --git a/src/dolphintabpage.cpp b/src/dolphintabpage.cpp new file mode 100644 index 0000000000..c8e4263359 --- /dev/null +++ b/src/dolphintabpage.cpp @@ -0,0 +1,258 @@ +/*************************************************************************** + * Copyright (C) 2014 by Emmanuel Pescosta * + * * + * 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 "dolphintabpage.h" + +#include "dolphinviewcontainer.h" +#include "dolphin_generalsettings.h" + +#include + +DolphinTabPage::DolphinTabPage(const KUrl& primaryUrl, const KUrl& secondaryUrl, QWidget* parent) : + QWidget(parent), + m_primaryViewActive(true), + m_splitViewEnabled(false) +{ + QVBoxLayout* layout = new QVBoxLayout(this); + layout->setSpacing(0); + layout->setMargin(0); + + m_splitter = new QSplitter(Qt::Horizontal, this); + m_splitter->setChildrenCollapsible(false); + layout->addWidget(m_splitter); + + // Create a new primary view + m_primaryViewContainer = createViewContainer(primaryUrl); + connect(m_primaryViewContainer->view(), SIGNAL(urlChanged(KUrl)), + this, SIGNAL(activeViewUrlChanged(KUrl))); + + m_splitter->addWidget(m_primaryViewContainer); + m_primaryViewContainer->show(); + + if (secondaryUrl.isValid() || GeneralSettings::splitView()) { + // Provide a secondary view, if the given secondary url is valid or if the + // startup settings are set this way (use the url of the primary view). + m_splitViewEnabled = true; + const KUrl& url = secondaryUrl.isValid() ? secondaryUrl : primaryUrl; + m_secondaryViewContainer = createViewContainer(url); + m_splitter->addWidget(m_secondaryViewContainer); + m_secondaryViewContainer->show(); + } + + m_primaryViewContainer->setActive(true); +} + +bool DolphinTabPage::primaryViewActive() const +{ + return m_primaryViewActive; +} + +bool DolphinTabPage::splitViewEnabled() const +{ + return m_splitViewEnabled; +} + +void DolphinTabPage::setSplitViewEnabled(bool enabled) +{ + if (m_splitViewEnabled != enabled) { + m_splitViewEnabled = enabled; + + if (enabled) { + const KUrl& url = m_primaryViewContainer->url(); + m_secondaryViewContainer = createViewContainer(url); + m_splitter->addWidget(m_secondaryViewContainer); + m_secondaryViewContainer->show(); + m_secondaryViewContainer->setActive(true); + } else { + // Close the view which is active. + DolphinViewContainer* view = activeViewContainer(); + if (m_primaryViewActive) { + // If the primary view is active, we have to swap the pointers + // because the secondary view will be the new primary view. + qSwap(m_primaryViewContainer, m_secondaryViewContainer); + } + m_primaryViewContainer->setActive(true); + view->close(); + view->deleteLater(); + } + } +} + +DolphinViewContainer* DolphinTabPage::primaryViewContainer() const +{ + return m_primaryViewContainer; +} + +DolphinViewContainer* DolphinTabPage::secondaryViewContainer() const +{ + return m_secondaryViewContainer; +} + +DolphinViewContainer* DolphinTabPage::activeViewContainer() const +{ + return m_primaryViewActive ? m_primaryViewContainer : + m_secondaryViewContainer; +} + +KFileItemList DolphinTabPage::selectedItems() const +{ + KFileItemList items = m_primaryViewContainer->view()->selectedItems(); + if (m_splitViewEnabled) { + items += m_secondaryViewContainer->view()->selectedItems(); + } + return items; +} + +int DolphinTabPage::selectedItemsCount() const +{ + int selectedItemsCount = m_primaryViewContainer->view()->selectedItemsCount(); + if (m_splitViewEnabled) { + selectedItemsCount += m_secondaryViewContainer->view()->selectedItemsCount(); + } + return selectedItemsCount; +} + +void DolphinTabPage::markUrlsAsSelected(const QList& urls) +{ + m_primaryViewContainer->view()->markUrlsAsSelected(urls); + if (m_splitViewEnabled) { + m_secondaryViewContainer->view()->markUrlsAsSelected(urls); + } +} + +void DolphinTabPage::markUrlAsCurrent(const KUrl& url) +{ + m_primaryViewContainer->view()->markUrlAsCurrent(url); + if (m_splitViewEnabled) { + m_secondaryViewContainer->view()->markUrlAsCurrent(url); + } +} + +void DolphinTabPage::setPlacesSelectorVisible(bool visible) +{ + m_primaryViewContainer->urlNavigator()->setPlacesSelectorVisible(visible); + if (m_splitViewEnabled) { + m_secondaryViewContainer->urlNavigator()->setPlacesSelectorVisible(visible); + } +} + +void DolphinTabPage::refreshViews() +{ + m_primaryViewContainer->readSettings(); + if (m_splitViewEnabled) { + m_secondaryViewContainer->readSettings(); + } +} + +QByteArray DolphinTabPage::saveState() const +{ + QByteArray state; + QDataStream stream(&state, QIODevice::WriteOnly); + + stream << m_splitViewEnabled; + + stream << m_primaryViewContainer->url(); + stream << m_primaryViewContainer->urlNavigator()->isUrlEditable(); + + if (m_splitViewEnabled) { + stream << m_secondaryViewContainer->url(); + stream << m_secondaryViewContainer->urlNavigator()->isUrlEditable(); + } + + stream << m_primaryViewActive; + stream << m_splitter->saveState(); + + return state; +} + +void DolphinTabPage::restoreState(const QByteArray& state) +{ + QByteArray sd = state; + QDataStream stream(&sd, QIODevice::ReadOnly); + + bool isSplitViewEnabled = false; + stream >> isSplitViewEnabled; + setSplitViewEnabled(isSplitViewEnabled); + + KUrl primaryUrl; + stream >> primaryUrl; + m_primaryViewContainer->setUrl(primaryUrl); + bool primaryUrlEditable; + stream >> primaryUrlEditable; + m_primaryViewContainer->urlNavigator()->setUrlEditable(primaryUrlEditable); + + if (isSplitViewEnabled) { + KUrl secondaryUrl; + stream >> secondaryUrl; + m_secondaryViewContainer->setUrl(secondaryUrl); + bool secondaryUrlEditable; + stream >> secondaryUrlEditable; + m_secondaryViewContainer->urlNavigator()->setUrlEditable(secondaryUrlEditable); + } + + stream >> m_primaryViewActive; + if (m_primaryViewActive) { + m_primaryViewContainer->setActive(true); + } else { + Q_ASSERT(m_splitViewEnabled); + m_secondaryViewContainer->setActive(true); + } + + QByteArray splitterState; + stream >> splitterState; + m_splitter->restoreState(splitterState); +} + +void DolphinTabPage::slotViewActivated() +{ + const DolphinView* oldActiveView = activeViewContainer()->view(); + + // Set the view, which was active before, to inactive + // and update the active view type. + if (m_splitViewEnabled) { + activeViewContainer()->setActive(false); + m_primaryViewActive = !m_primaryViewActive; + } else { + m_primaryViewActive = true; + } + + const DolphinView* newActiveView = activeViewContainer()->view(); + + if (newActiveView != oldActiveView) { + disconnect(oldActiveView, SIGNAL(urlChanged(KUrl)), + this, SIGNAL(activeViewUrlChanged(KUrl))); + connect(newActiveView, SIGNAL(urlChanged(KUrl)), + this, SIGNAL(activeViewUrlChanged(KUrl))); + } + + emit activeViewUrlChanged(activeViewContainer()->url()); + emit activeViewChanged(); +} + +DolphinViewContainer* DolphinTabPage::createViewContainer(const KUrl& url) const +{ + DolphinViewContainer* container = new DolphinViewContainer(url, m_splitter); + container->setActive(false); + + const DolphinView* view = container->view(); + connect(view, SIGNAL(activated()), + this, SLOT(slotViewActivated())); + + return container; +} diff --git a/src/dolphintabpage.h b/src/dolphintabpage.h new file mode 100644 index 0000000000..95c02ed0a1 --- /dev/null +++ b/src/dolphintabpage.h @@ -0,0 +1,152 @@ +/*************************************************************************** + * Copyright (C) 2014 by Emmanuel Pescosta * + * * + * 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 * + ***************************************************************************/ + +#ifndef DOLPHIN_TAB_PAGE_H +#define DOLPHIN_TAB_PAGE_H + +#include +#include +#include + +class QSplitter; +class DolphinViewContainer; +class KFileItemList; + +class DolphinTabPage : public QWidget +{ + Q_OBJECT + +public: + explicit DolphinTabPage(const KUrl& primaryUrl, const KUrl& secondaryUrl = KUrl(), QWidget* parent = 0); + + /** + * @return True if primary view is the active view in this tab. + */ + bool primaryViewActive() const; + + /** + * @return True if split view is enabled. + */ + bool splitViewEnabled() const; + + /** + * Enables or disables the split view mode. + * + * If \a enabled is true, it creates a secondary view with the url of the primary view. + */ + void setSplitViewEnabled(bool enabled); + + /** + * @return The primary view containter. + */ + DolphinViewContainer* primaryViewContainer() const; + + /** + * @return The secondary view containter, can be 0 if split view is disabled. + */ + DolphinViewContainer* secondaryViewContainer() const; + + /** + * @return DolphinViewContainer of the active view + */ + DolphinViewContainer* activeViewContainer() const; + + /** + * Returns the selected items. The list is empty if no item has been + * selected. + */ + KFileItemList selectedItems() const; + + /** + * Returns the number of selected items (this is faster than + * invoking selectedItems().count()). + */ + int selectedItemsCount() const; + + /** + * Marks the items indicated by \p urls to get selected after the + * directory DolphinView::url() has been loaded. Note that nothing + * gets selected if no loading of a directory has been triggered + * by DolphinView::setUrl() or DolphinView::reload(). + */ + void markUrlsAsSelected(const QList& urls); + + /** + * Marks the item indicated by \p url to be scrolled to and as the + * current item after directory DolphinView::url() has been loaded. + */ + void markUrlAsCurrent(const KUrl& url); + + /** + * Sets the places selector visible, if \a visible is true. + * The places selector allows to select the places provided + * by the places model passed in the constructor. Per default + * the places selector is visible. + */ + void setPlacesSelectorVisible(bool visible); + + /** + * Refreshes the views of the main window by recreating them according to + * the given Dolphin settings. + */ + void refreshViews(); + + /** + * Saves all tab related properties (urls, splitter layout, ...). + * + * @return A byte-array which contains all properties. + */ + QByteArray saveState() const; + + /** + * Restores all tab related properties (urls, splitter layout, ...) from + * the given \a state. + */ + void restoreState(const QByteArray& state); + +signals: + void activeViewChanged(); + void activeViewUrlChanged(const KUrl& url); + +private slots: + /** + * Handles the view activated event. + * + * It sets the previous active view to inactive, updates the current + * active view type and triggers the activeViewChanged event. + */ + void slotViewActivated(); + +private: + /** + * Creates a new view container and does the default initialization. + */ + DolphinViewContainer* createViewContainer(const KUrl& url) const; + +private: + QSplitter* m_splitter; + + QPointer m_primaryViewContainer; + QPointer m_secondaryViewContainer; + + bool m_primaryViewActive; + bool m_splitViewEnabled; +}; + +#endif // DOLPHIN_TAB_PAGE_H diff --git a/src/dolphinviewcontainer.cpp b/src/dolphinviewcontainer.cpp index 57452b9e4f..2a45152bd0 100644 --- a/src/dolphinviewcontainer.cpp +++ b/src/dolphinviewcontainer.cpp @@ -125,6 +125,7 @@ DolphinViewContainer::DolphinViewContainer(const KUrl& url, QWidget* parent) : connect(m_view, SIGNAL(urlAboutToBeChanged(KUrl)), this, SLOT(slotViewUrlAboutToBeChanged(KUrl))); connect(m_view, SIGNAL(errorMessage(QString)), this, SLOT(showErrorMessage(QString))); connect(m_view, SIGNAL(urlIsFileError(KUrl)), this, SLOT(slotUrlIsFileError(KUrl))); + connect(m_view, SIGNAL(activated()), this, SLOT(activate())); connect(m_urlNavigator, SIGNAL(urlAboutToBeChanged(KUrl)), this, SLOT(slotUrlNavigatorLocationAboutToBeChanged(KUrl)));