X-Git-Url: https://cloud.milkyroute.net/gitweb/dolphin.git/blobdiff_plain/362244ccbe694442b9145bbcea975f91b4c44af1..844d1c05477a3137cce54561514c851bdfe49406:/src/dolphintabpage.cpp diff --git a/src/dolphintabpage.cpp b/src/dolphintabpage.cpp index b2bb5c896..33c77c42a 100644 --- a/src/dolphintabpage.cpp +++ b/src/dolphintabpage.cpp @@ -1,43 +1,39 @@ -/*************************************************************************** - * 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-FileCopyrightText: 2020 Felix Ernst + * + * SPDX-License-Identifier: GPL-2.0-or-later + */ #include "dolphintabpage.h" #include "dolphin_generalsettings.h" #include "dolphinviewcontainer.h" +#include "global.h" +#include #include -#include +#include +#include +#include DolphinTabPage::DolphinTabPage(const QUrl &primaryUrl, const QUrl &secondaryUrl, QWidget* parent) : QWidget(parent), + m_expandingContainer{nullptr}, m_primaryViewActive(true), m_splitViewEnabled(false), m_active(true) { - QVBoxLayout* layout = new QVBoxLayout(this); + QGridLayout *layout = new QGridLayout(this); layout->setSpacing(0); - layout->setMargin(0); + layout->setContentsMargins(0, 0, 0, 0); m_splitter = new QSplitter(Qt::Horizontal, this); m_splitter->setChildrenCollapsible(false); - layout->addWidget(m_splitter); + connect(m_splitter, &QSplitter::splitterMoved, + this, &DolphinTabPage::splitterMoved); + layout->addWidget(m_splitter, 1, 0); + layout->setRowStretch(1, 1); // Create a new primary view m_primaryViewContainer = createViewContainer(primaryUrl); @@ -72,33 +68,91 @@ bool DolphinTabPage::splitViewEnabled() const return m_splitViewEnabled; } -void DolphinTabPage::setSplitViewEnabled(bool enabled, const QUrl &secondaryUrl) +void DolphinTabPage::setSplitViewEnabled(bool enabled, Animated animated, const QUrl &secondaryUrl) { if (m_splitViewEnabled != enabled) { m_splitViewEnabled = enabled; + if (animated == WithAnimation && ( + style()->styleHint(QStyle::SH_Widget_Animation_Duration, nullptr, this) < 1 || + GlobalConfig::animationDurationFactor() <= 0.0)) { + animated = WithoutAnimation; + } + if (m_expandViewAnimation) { + m_expandViewAnimation->stop(); // deletes because of QAbstractAnimation::DeleteWhenStopped. + if (animated == WithoutAnimation) { + slotAnimationFinished(); + } + } if (enabled) { + QList splitterSizes = m_splitter->sizes(); const QUrl& url = (secondaryUrl.isEmpty()) ? m_primaryViewContainer->url() : secondaryUrl; m_secondaryViewContainer = createViewContainer(url); - const bool placesSelectorVisible = m_primaryViewContainer->urlNavigator()->isPlacesSelectorVisible(); - m_secondaryViewContainer->urlNavigator()->setPlacesSelectorVisible(placesSelectorVisible); + auto secondaryNavigator = m_navigatorsWidget->secondaryUrlNavigator(); + if (!secondaryNavigator) { + m_navigatorsWidget->createSecondaryUrlNavigator(); + secondaryNavigator = m_navigatorsWidget->secondaryUrlNavigator(); + } + m_secondaryViewContainer->connectUrlNavigator(secondaryNavigator); + m_navigatorsWidget->setSecondaryNavigatorVisible(true); + m_navigatorsWidget->followViewContainersGeometry(m_primaryViewContainer, + m_secondaryViewContainer); m_splitter->addWidget(m_secondaryViewContainer); - m_secondaryViewContainer->show(); m_secondaryViewContainer->setActive(true); + + if (animated == WithAnimation) { + m_secondaryViewContainer->setMinimumWidth(1); + splitterSizes.append(1); + m_splitter->setSizes(splitterSizes); + startExpandViewAnimation(m_secondaryViewContainer); + } + m_secondaryViewContainer->show(); } 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_primaryViewActive = false; + 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(); - view->deleteLater(); + m_navigatorsWidget->followViewContainersGeometry(m_primaryViewContainer, nullptr); + + if (animated == WithoutAnimation) { + view->close(); + view->deleteLater(); + } else { + // Kill it but keep it as a zombie for the closing animation. + m_secondaryViewContainer = nullptr; + view->blockSignals(true); + view->view()->blockSignals(true); + view->setDisabled(true); + startExpandViewAnimation(m_primaryViewContainer); + } } } } @@ -137,6 +191,42 @@ int DolphinTabPage::selectedItemsCount() const return selectedItemsCount; } +void DolphinTabPage::connectNavigators(DolphinNavigatorsWidgetAction *navigatorsWidget) +{ + insertNavigatorsWidget(navigatorsWidget); + m_navigatorsWidget = navigatorsWidget; + auto primaryNavigator = navigatorsWidget->primaryUrlNavigator(); + m_primaryViewContainer->connectUrlNavigator(primaryNavigator); + if (m_splitViewEnabled) { + auto secondaryNavigator = navigatorsWidget->secondaryUrlNavigator(); + m_secondaryViewContainer->connectUrlNavigator(secondaryNavigator); + } + m_navigatorsWidget->followViewContainersGeometry(m_primaryViewContainer, + m_secondaryViewContainer); +} + +void DolphinTabPage::disconnectNavigators() +{ + m_navigatorsWidget = nullptr; + m_primaryViewContainer->disconnectUrlNavigator(); + if (m_splitViewEnabled) { + m_secondaryViewContainer->disconnectUrlNavigator(); + } +} + +void DolphinTabPage::insertNavigatorsWidget(DolphinNavigatorsWidgetAction* navigatorsWidget) +{ + QGridLayout *gridLayout = static_cast(layout()); + if (navigatorsWidget->isInToolbar()) { + gridLayout->setRowMinimumHeight(0, 0); + } else { + // We set a row minimum height, so the height does not visibly change whenever + // navigatorsWidget is inserted which happens every time the current tab is changed. + gridLayout->setRowMinimumHeight(0, navigatorsWidget->primaryUrlNavigator()->height()); + gridLayout->addWidget(navigatorsWidget->requestWidget(this), 0, 0); + } +} + void DolphinTabPage::markUrlsAsSelected(const QList& urls) { m_primaryViewContainer->view()->markUrlsAsSelected(urls); @@ -153,14 +243,6 @@ void DolphinTabPage::markUrlAsCurrent(const QUrl& 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(); @@ -179,12 +261,12 @@ QByteArray DolphinTabPage::saveState() const 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); } @@ -213,14 +295,14 @@ void DolphinTabPage::restoreState(const QByteArray& state) bool isSplitViewEnabled = false; stream >> isSplitViewEnabled; - setSplitViewEnabled(isSplitViewEnabled); + setSplitViewEnabled(isSplitViewEnabled, WithoutAnimation); 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) { @@ -229,7 +311,7 @@ void DolphinTabPage::restoreState(const QByteArray& state) m_secondaryViewContainer->setUrl(secondaryUrl); bool secondaryUrlEditable; stream >> secondaryUrlEditable; - m_secondaryViewContainer->urlNavigator()->setUrlEditable(secondaryUrlEditable); + m_secondaryViewContainer->urlNavigatorInternalWithHistory()->setUrlEditable(secondaryUrlEditable); m_secondaryViewContainer->view()->restoreState(stream); } @@ -246,48 +328,6 @@ 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->urlNavigator()->setUrlEditable(primaryUrlEditable); - - if (isSplitViewEnabled) { - QUrl 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::setActive(bool active) { if (active) { @@ -300,6 +340,72 @@ void DolphinTabPage::setActive(bool active) activeViewContainer()->setActive(active); } +void DolphinTabPage::slotAnimationFinished() +{ + for (int i = 0; i < m_splitter->count(); ++i) { + QWidget *viewContainer = m_splitter->widget(i); + if (viewContainer != m_primaryViewContainer && + viewContainer != m_secondaryViewContainer) { + viewContainer->close(); + viewContainer->deleteLater(); + } + } + for (int i = 0; i < m_splitter->count(); ++i) { + QWidget *viewContainer = m_splitter->widget(i); + viewContainer->setMinimumWidth(viewContainer->minimumSizeHint().width()); + } + m_expandingContainer = nullptr; +} + +void DolphinTabPage::slotAnimationValueChanged(const QVariant& value) +{ + Q_CHECK_PTR(m_expandingContainer); + const int indexOfExpandingContainer = m_splitter->indexOf(m_expandingContainer); + int indexOfNonExpandingContainer = -1; + if (m_expandingContainer == m_primaryViewContainer) { + indexOfNonExpandingContainer = m_splitter->indexOf(m_secondaryViewContainer); + } else { + indexOfNonExpandingContainer = m_splitter->indexOf(m_primaryViewContainer); + } + std::vector widgetsToRemove; + const QList oldSplitterSizes = m_splitter->sizes(); + QList newSplitterSizes{oldSplitterSizes}; + int expansionWidthNeeded = value.toInt() - oldSplitterSizes.at(indexOfExpandingContainer); + + // Reduce the size of the other widgets to make space for the expandingContainer. + for (int i = m_splitter->count() - 1; i >= 0; --i) { + if (m_splitter->widget(i) == m_primaryViewContainer || + m_splitter->widget(i) == m_secondaryViewContainer) { + continue; + } + newSplitterSizes[i] = oldSplitterSizes.at(i) - expansionWidthNeeded; + expansionWidthNeeded = 0; + if (indexOfNonExpandingContainer != -1) { + // Make sure every zombie container is at least slightly reduced in size + // so it doesn't seem like they are here to stay. + newSplitterSizes[i]--; + newSplitterSizes[indexOfNonExpandingContainer]++; + } + if (newSplitterSizes.at(i) <= 0) { + expansionWidthNeeded -= newSplitterSizes.at(i); + newSplitterSizes[i] = 0; + widgetsToRemove.emplace_back(m_splitter->widget(i)); + } + } + if (expansionWidthNeeded > 1 && indexOfNonExpandingContainer != -1) { + Q_ASSERT(m_splitViewEnabled); + newSplitterSizes[indexOfNonExpandingContainer] -= expansionWidthNeeded; + } + newSplitterSizes[indexOfExpandingContainer] = value.toInt(); + m_splitter->setSizes(newSplitterSizes); + while (!widgetsToRemove.empty()) { + widgetsToRemove.back()->close(); + widgetsToRemove.back()->deleteLater(); + widgetsToRemove.pop_back(); + } +} + + void DolphinTabPage::slotViewActivated() { const DolphinView* oldActiveView = activeViewContainer()->view(); @@ -320,26 +426,27 @@ void DolphinTabPage::slotViewActivated() const DolphinView* newActiveView = activeViewContainer()->view(); - if (newActiveView != oldActiveView) { - 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); + if (newActiveView == oldActiveView) { + return; } - emit activeViewUrlChanged(activeViewContainer()->url()); - emit activeViewChanged(activeViewContainer()); + 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_UNUSED(oldUrl) - emit activeViewUrlChanged(newUrl); + Q_EMIT activeViewUrlChanged(newUrl); } void DolphinTabPage::switchActiveView() @@ -368,3 +475,33 @@ DolphinViewContainer* DolphinTabPage::createViewContainer(const QUrl& url) const return container; } + +void DolphinTabPage::startExpandViewAnimation(DolphinViewContainer *expandingContainer) +{ + Q_CHECK_PTR(expandingContainer); + Q_ASSERT(expandingContainer == m_primaryViewContainer || + expandingContainer == m_secondaryViewContainer); + m_expandingContainer = expandingContainer; + + m_expandViewAnimation = new QVariantAnimation(m_splitter); + m_expandViewAnimation->setDuration(2 * + style()->styleHint(QStyle::SH_Widget_Animation_Duration, nullptr, this) * + GlobalConfig::animationDurationFactor()); + for (int i = 0; i < m_splitter->count(); ++i) { + m_splitter->widget(i)->setMinimumWidth(1); + } + connect(m_expandViewAnimation, &QAbstractAnimation::finished, + this, &DolphinTabPage::slotAnimationFinished); + connect(m_expandViewAnimation, &QVariantAnimation::valueChanged, + this, &DolphinTabPage::slotAnimationValueChanged); + + m_expandViewAnimation->setStartValue(expandingContainer->width()); + if (m_splitViewEnabled) { // A new viewContainer is being opened. + m_expandViewAnimation->setEndValue(m_splitter->width() / 2); + m_expandViewAnimation->setEasingCurve(QEasingCurve::OutCubic); + } else { // A viewContainer is being closed. + m_expandViewAnimation->setEndValue(m_splitter->width()); + m_expandViewAnimation->setEasingCurve(QEasingCurve::InCubic); + } + m_expandViewAnimation->start(QAbstractAnimation::DeleteWhenStopped); +}