X-Git-Url: https://cloud.milkyroute.net/gitweb/dolphin.git/blobdiff_plain/fc4315d57e8fe64d05aad2a1c24800f0149b21da..a418d6229e31dac254660da2a417b4306f066ae3:/src/dolphintabpage.cpp diff --git a/src/dolphintabpage.cpp b/src/dolphintabpage.cpp index c8e426335..d196508a8 100644 --- a/src/dolphintabpage.cpp +++ b/src/dolphintabpage.cpp @@ -1,57 +1,52 @@ -/*************************************************************************** - * 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 * - ***************************************************************************/ +/* + * SPDX-FileCopyrightText: 2014 Emmanuel Pescosta + * + * SPDX-License-Identifier: GPL-2.0-or-later + */ #include "dolphintabpage.h" -#include "dolphinviewcontainer.h" #include "dolphin_generalsettings.h" +#include "dolphinviewcontainer.h" #include +#include -DolphinTabPage::DolphinTabPage(const KUrl& primaryUrl, const KUrl& secondaryUrl, QWidget* parent) : +DolphinTabPage::DolphinTabPage(const QUrl &primaryUrl, const QUrl &secondaryUrl, QWidget* parent) : QWidget(parent), m_primaryViewActive(true), - m_splitViewEnabled(false) + m_splitViewEnabled(false), + m_active(true) { QVBoxLayout* layout = new QVBoxLayout(this); layout->setSpacing(0); - layout->setMargin(0); + layout->setContentsMargins(0, 0, 0, 0); m_splitter = new QSplitter(Qt::Horizontal, this); m_splitter->setChildrenCollapsible(false); + connect(m_splitter, &QSplitter::splitterMoved, + this, &DolphinTabPage::splitterMoved); layout->addWidget(m_splitter); // Create a new primary view m_primaryViewContainer = createViewContainer(primaryUrl); - connect(m_primaryViewContainer->view(), SIGNAL(urlChanged(KUrl)), - this, SIGNAL(activeViewUrlChanged(KUrl))); + connect(m_primaryViewContainer->view(), &DolphinView::urlChanged, + this, &DolphinTabPage::activeViewUrlChanged); + connect(m_primaryViewContainer->view(), &DolphinView::redirection, + this, &DolphinTabPage::slotViewUrlRedirection); m_splitter->addWidget(m_primaryViewContainer); + m_primaryViewContainer->installEventFilter(this); 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; + const QUrl& url = secondaryUrl.isValid() ? secondaryUrl : primaryUrl; m_secondaryViewContainer = createViewContainer(url); m_splitter->addWidget(m_secondaryViewContainer); + m_secondaryViewContainer->installEventFilter(this); m_secondaryViewContainer->show(); } @@ -68,24 +63,56 @@ bool DolphinTabPage::splitViewEnabled() const return m_splitViewEnabled; } -void DolphinTabPage::setSplitViewEnabled(bool enabled) +void DolphinTabPage::setSplitViewEnabled(bool enabled, const QUrl &secondaryUrl) { if (m_splitViewEnabled != enabled) { m_splitViewEnabled = enabled; if (enabled) { - const KUrl& url = m_primaryViewContainer->url(); + const QUrl& url = (secondaryUrl.isEmpty()) ? m_primaryViewContainer->url() : secondaryUrl; m_secondaryViewContainer = createViewContainer(url); + + auto secondaryNavigator = m_navigatorsWidget->secondaryUrlNavigator(); + if (!secondaryNavigator) { + m_navigatorsWidget->createSecondaryUrlNavigator(); + secondaryNavigator = m_navigatorsWidget->secondaryUrlNavigator(); + } + m_secondaryViewContainer->connectUrlNavigator(secondaryNavigator); + m_navigatorsWidget->setSecondaryNavigatorVisible(true); + m_splitter->addWidget(m_secondaryViewContainer); + m_secondaryViewContainer->installEventFilter(this); 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_navigatorsWidget->setSecondaryNavigatorVisible(false); + m_secondaryViewContainer->disconnectUrlNavigator(); + + DolphinViewContainer* view; + if (GeneralSettings::closeActiveSplitView()) { + view = activeViewContainer(); + if (m_primaryViewActive) { + m_primaryViewContainer->disconnectUrlNavigator(); + m_secondaryViewContainer->connectUrlNavigator( + m_navigatorsWidget->primaryUrlNavigator()); + + // 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_primaryViewActive = false; + } + } else { + view = m_primaryViewActive ? m_secondaryViewContainer : m_primaryViewContainer; + if (!m_primaryViewActive) { + m_primaryViewContainer->disconnectUrlNavigator(); + m_secondaryViewContainer->connectUrlNavigator( + m_navigatorsWidget->primaryUrlNavigator()); + + // If the secondary 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_primaryViewActive = true; + } } m_primaryViewContainer->setActive(true); view->close(); @@ -128,27 +155,65 @@ int DolphinTabPage::selectedItemsCount() const return selectedItemsCount; } -void DolphinTabPage::markUrlsAsSelected(const QList& urls) +void DolphinTabPage::connectNavigators(DolphinNavigatorsWidgetAction *navigatorsWidget) { - m_primaryViewContainer->view()->markUrlsAsSelected(urls); + m_navigatorsWidget = navigatorsWidget; + auto primaryNavigator = navigatorsWidget->primaryUrlNavigator(); + primaryNavigator->setActive(m_primaryViewActive); + m_primaryViewContainer->connectUrlNavigator(primaryNavigator); if (m_splitViewEnabled) { - m_secondaryViewContainer->view()->markUrlsAsSelected(urls); + auto secondaryNavigator = navigatorsWidget->secondaryUrlNavigator(); + secondaryNavigator->setActive(!m_primaryViewActive); + m_secondaryViewContainer->connectUrlNavigator(secondaryNavigator); } + resizeNavigators(); } -void DolphinTabPage::markUrlAsCurrent(const KUrl& url) +void DolphinTabPage::disconnectNavigators() { - m_primaryViewContainer->view()->markUrlAsCurrent(url); + m_navigatorsWidget = nullptr; + m_primaryViewContainer->disconnectUrlNavigator(); if (m_splitViewEnabled) { - m_secondaryViewContainer->view()->markUrlAsCurrent(url); + m_secondaryViewContainer->disconnectUrlNavigator(); } } -void DolphinTabPage::setPlacesSelectorVisible(bool visible) +bool DolphinTabPage::eventFilter(QObject */* watched */, QEvent *event) { - m_primaryViewContainer->urlNavigator()->setPlacesSelectorVisible(visible); + if (event->type() == QEvent::Resize && m_navigatorsWidget) { + resizeNavigators(); + } + return false; +} + +void DolphinTabPage::resizeNavigators() const +{ + if (!m_splitViewEnabled) { + m_navigatorsWidget->followViewContainerGeometry( + m_primaryViewContainer->mapToGlobal(QPoint(0,0)).x(), + m_primaryViewContainer->width()); + } else { + m_navigatorsWidget->followViewContainersGeometry( + m_primaryViewContainer->mapToGlobal(QPoint(0,0)).x(), + m_primaryViewContainer->width(), + m_secondaryViewContainer->mapToGlobal(QPoint(0,0)).x(), + m_secondaryViewContainer->width()); + } +} + +void DolphinTabPage::markUrlsAsSelected(const QList& urls) +{ + m_primaryViewContainer->view()->markUrlsAsSelected(urls); if (m_splitViewEnabled) { - m_secondaryViewContainer->urlNavigator()->setPlacesSelectorVisible(visible); + m_secondaryViewContainer->view()->markUrlsAsSelected(urls); + } +} + +void DolphinTabPage::markUrlAsCurrent(const QUrl& url) +{ + m_primaryViewContainer->view()->markUrlAsCurrent(url); + if (m_splitViewEnabled) { + m_secondaryViewContainer->view()->markUrlAsCurrent(url); } } @@ -165,14 +230,18 @@ QByteArray DolphinTabPage::saveState() const QByteArray state; QDataStream stream(&state, QIODevice::WriteOnly); + stream << quint32(2); // Tab state version + stream << m_splitViewEnabled; stream << m_primaryViewContainer->url(); - stream << m_primaryViewContainer->urlNavigator()->isUrlEditable(); + stream << m_primaryViewContainer->urlNavigatorInternalWithHistory()->isUrlEditable(); + m_primaryViewContainer->view()->saveState(stream); if (m_splitViewEnabled) { stream << m_secondaryViewContainer->url(); - stream << m_secondaryViewContainer->urlNavigator()->isUrlEditable(); + stream << m_secondaryViewContainer->urlNavigatorInternalWithHistory()->isUrlEditable(); + m_secondaryViewContainer->view()->saveState(stream); } stream << m_primaryViewActive; @@ -183,35 +252,51 @@ QByteArray DolphinTabPage::saveState() const void DolphinTabPage::restoreState(const QByteArray& state) { + if (state.isEmpty()) { + return; + } + QByteArray sd = state; QDataStream stream(&sd, QIODevice::ReadOnly); + // Read the version number of the tab state and check if the version is supported. + quint32 version = 0; + stream >> version; + if (version != 2) { + // The version of the tab state isn't supported, we can't restore it. + return; + } + bool isSplitViewEnabled = false; stream >> isSplitViewEnabled; setSplitViewEnabled(isSplitViewEnabled); - KUrl primaryUrl; + QUrl primaryUrl; stream >> primaryUrl; m_primaryViewContainer->setUrl(primaryUrl); bool primaryUrlEditable; stream >> primaryUrlEditable; - m_primaryViewContainer->urlNavigator()->setUrlEditable(primaryUrlEditable); + m_primaryViewContainer->urlNavigatorInternalWithHistory()->setUrlEditable(primaryUrlEditable); + m_primaryViewContainer->view()->restoreState(stream); if (isSplitViewEnabled) { - KUrl secondaryUrl; + QUrl secondaryUrl; stream >> secondaryUrl; m_secondaryViewContainer->setUrl(secondaryUrl); bool secondaryUrlEditable; stream >> secondaryUrlEditable; - m_secondaryViewContainer->urlNavigator()->setUrlEditable(secondaryUrlEditable); + m_secondaryViewContainer->urlNavigatorInternalWithHistory()->setUrlEditable(secondaryUrlEditable); + m_secondaryViewContainer->view()->restoreState(stream); } stream >> m_primaryViewActive; if (m_primaryViewActive) { m_primaryViewContainer->setActive(true); + m_navigatorsWidget->primaryUrlNavigator()->setActive(true); } else { Q_ASSERT(m_splitViewEnabled); m_secondaryViewContainer->setActive(true); + m_navigatorsWidget->primaryUrlNavigator()->setActive(false); } QByteArray splitterState; @@ -219,40 +304,126 @@ void DolphinTabPage::restoreState(const QByteArray& state) m_splitter->restoreState(splitterState); } +void DolphinTabPage::restoreStateV1(const QByteArray& state) +{ + if (state.isEmpty()) { + return; + } + + QByteArray sd = state; + QDataStream stream(&sd, QIODevice::ReadOnly); + + bool isSplitViewEnabled = false; + stream >> isSplitViewEnabled; + setSplitViewEnabled(isSplitViewEnabled); + + QUrl primaryUrl; + stream >> primaryUrl; + m_primaryViewContainer->setUrl(primaryUrl); + bool primaryUrlEditable; + stream >> primaryUrlEditable; + m_primaryViewContainer->urlNavigatorInternalWithHistory()->setUrlEditable(primaryUrlEditable); + + if (isSplitViewEnabled) { + QUrl secondaryUrl; + stream >> secondaryUrl; + m_secondaryViewContainer->setUrl(secondaryUrl); + bool secondaryUrlEditable; + stream >> secondaryUrlEditable; + m_secondaryViewContainer->urlNavigatorInternalWithHistory()->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::setActive(bool active) +{ + if (active) { + m_active = active; + } else { + // we should bypass changing active view in split mode + m_active = !m_splitViewEnabled; + } + // we want view to fire activated when goes from false to true + activeViewContainer()->setActive(active); +} + 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; + // and update the active view type, if tab is active + if (m_active) { + if (m_splitViewEnabled) { + activeViewContainer()->setActive(false); + m_primaryViewActive = !m_primaryViewActive; + } else { + m_primaryViewActive = true; + if (m_secondaryViewContainer) { + m_secondaryViewContainer->setActive(false); + } + } } 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))); + if (newActiveView == oldActiveView) { + return; } - emit activeViewUrlChanged(activeViewContainer()->url()); - emit activeViewChanged(); + disconnect(oldActiveView, &DolphinView::urlChanged, + this, &DolphinTabPage::activeViewUrlChanged); + disconnect(oldActiveView, &DolphinView::redirection, + this, &DolphinTabPage::slotViewUrlRedirection); + connect(newActiveView, &DolphinView::urlChanged, + this, &DolphinTabPage::activeViewUrlChanged); + connect(newActiveView, &DolphinView::redirection, + this, &DolphinTabPage::slotViewUrlRedirection); + Q_EMIT activeViewChanged(activeViewContainer()); + Q_EMIT activeViewUrlChanged(activeViewContainer()->url()); +} + +void DolphinTabPage::slotViewUrlRedirection(const QUrl& oldUrl, const QUrl& newUrl) +{ + Q_UNUSED(oldUrl) + + Q_EMIT activeViewUrlChanged(newUrl); } -DolphinViewContainer* DolphinTabPage::createViewContainer(const KUrl& url) const +void DolphinTabPage::switchActiveView() +{ + if (!m_splitViewEnabled) { + return; + } + if (m_primaryViewActive) { + m_secondaryViewContainer->setActive(true); + } else { + m_primaryViewContainer->setActive(true); + } +} + +DolphinViewContainer* DolphinTabPage::createViewContainer(const QUrl& url) const { DolphinViewContainer* container = new DolphinViewContainer(url, m_splitter); container->setActive(false); const DolphinView* view = container->view(); - connect(view, SIGNAL(activated()), - this, SLOT(slotViewActivated())); + connect(view, &DolphinView::activated, + this, &DolphinTabPage::slotViewActivated); + + connect(view, &DolphinView::toggleActiveViewRequested, + this, &DolphinTabPage::switchActiveView); return container; }