2020-08-25 17:07:38 +00:00
|
|
|
/*
|
|
|
|
* SPDX-FileCopyrightText: 2014 Emmanuel Pescosta <emmanuelpescosta099@gmail.com>
|
2023-06-04 16:09:42 +00:00
|
|
|
* SPDX-FileCopyrightText: 2020 Felix Ernst <felixernst@kde.org>
|
2020-08-25 17:07:38 +00:00
|
|
|
*
|
|
|
|
* SPDX-License-Identifier: GPL-2.0-or-later
|
|
|
|
*/
|
2014-07-02 13:30:37 +00:00
|
|
|
|
|
|
|
#include "dolphintabpage.h"
|
|
|
|
|
|
|
|
#include "dolphin_generalsettings.h"
|
2018-03-04 13:38:16 +00:00
|
|
|
#include "dolphinviewcontainer.h"
|
2014-07-02 13:30:37 +00:00
|
|
|
|
2020-11-19 21:22:27 +00:00
|
|
|
#include <QGridLayout>
|
2021-01-02 17:48:52 +00:00
|
|
|
#include <QStyle>
|
2022-09-26 06:17:13 +00:00
|
|
|
#include <QVariantAnimation>
|
2014-07-02 13:30:37 +00:00
|
|
|
|
2023-02-03 17:14:53 +00:00
|
|
|
DolphinTabPage::DolphinTabPage(const QUrl &primaryUrl, const QUrl &secondaryUrl, QWidget *parent)
|
|
|
|
: QWidget(parent)
|
|
|
|
, m_expandingContainer{nullptr}
|
|
|
|
, m_primaryViewActive(true)
|
|
|
|
, m_splitViewEnabled(false)
|
|
|
|
, m_active(true)
|
2014-07-02 13:30:37 +00:00
|
|
|
{
|
2020-11-19 21:22:27 +00:00
|
|
|
QGridLayout *layout = new QGridLayout(this);
|
2014-07-02 13:30:37 +00:00
|
|
|
layout->setSpacing(0);
|
2019-02-27 07:59:18 +00:00
|
|
|
layout->setContentsMargins(0, 0, 0, 0);
|
2014-07-02 13:30:37 +00:00
|
|
|
|
2021-08-30 14:18:21 +00:00
|
|
|
m_splitter = new DolphinTabPageSplitter(Qt::Horizontal, this);
|
2014-07-02 13:30:37 +00:00
|
|
|
m_splitter->setChildrenCollapsible(false);
|
2023-02-03 17:14:53 +00:00
|
|
|
connect(m_splitter, &QSplitter::splitterMoved, this, &DolphinTabPage::splitterMoved);
|
2020-11-19 21:22:27 +00:00
|
|
|
layout->addWidget(m_splitter, 1, 0);
|
|
|
|
layout->setRowStretch(1, 1);
|
2014-07-02 13:30:37 +00:00
|
|
|
|
|
|
|
// Create a new primary view
|
|
|
|
m_primaryViewContainer = createViewContainer(primaryUrl);
|
2023-02-03 17:14:53 +00:00
|
|
|
connect(m_primaryViewContainer->view(), &DolphinView::urlChanged, this, &DolphinTabPage::activeViewUrlChanged);
|
|
|
|
connect(m_primaryViewContainer->view(), &DolphinView::redirection, this, &DolphinTabPage::slotViewUrlRedirection);
|
2014-07-02 13:30:37 +00:00
|
|
|
|
|
|
|
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;
|
2023-02-03 17:14:53 +00:00
|
|
|
const QUrl &url = secondaryUrl.isValid() ? secondaryUrl : primaryUrl;
|
2014-07-02 13:30:37 +00:00
|
|
|
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;
|
|
|
|
}
|
|
|
|
|
2021-01-02 17:48:52 +00:00
|
|
|
void DolphinTabPage::setSplitViewEnabled(bool enabled, Animated animated, const QUrl &secondaryUrl)
|
2014-07-02 13:30:37 +00:00
|
|
|
{
|
|
|
|
if (m_splitViewEnabled != enabled) {
|
|
|
|
m_splitViewEnabled = enabled;
|
2023-02-03 17:14:53 +00:00
|
|
|
if (animated == WithAnimation
|
|
|
|
&& (style()->styleHint(QStyle::SH_Widget_Animation_Duration, nullptr, this) < 1 || GlobalConfig::animationDurationFactor() <= 0.0)) {
|
2021-01-02 17:48:52 +00:00
|
|
|
animated = WithoutAnimation;
|
|
|
|
}
|
|
|
|
if (m_expandViewAnimation) {
|
|
|
|
m_expandViewAnimation->stop(); // deletes because of QAbstractAnimation::DeleteWhenStopped.
|
|
|
|
if (animated == WithoutAnimation) {
|
|
|
|
slotAnimationFinished();
|
|
|
|
}
|
|
|
|
}
|
2016-09-27 05:07:08 +00:00
|
|
|
|
2014-07-02 13:30:37 +00:00
|
|
|
if (enabled) {
|
2021-01-02 17:48:52 +00:00
|
|
|
QList<int> splitterSizes = m_splitter->sizes();
|
2023-02-03 17:14:53 +00:00
|
|
|
const QUrl &url = (secondaryUrl.isEmpty()) ? m_primaryViewContainer->url() : secondaryUrl;
|
2014-07-02 13:30:37 +00:00
|
|
|
m_secondaryViewContainer = createViewContainer(url);
|
2014-07-16 07:12:16 +00:00
|
|
|
|
2020-09-20 16:53:59 +00:00
|
|
|
auto secondaryNavigator = m_navigatorsWidget->secondaryUrlNavigator();
|
|
|
|
if (!secondaryNavigator) {
|
|
|
|
m_navigatorsWidget->createSecondaryUrlNavigator();
|
|
|
|
secondaryNavigator = m_navigatorsWidget->secondaryUrlNavigator();
|
|
|
|
}
|
|
|
|
m_secondaryViewContainer->connectUrlNavigator(secondaryNavigator);
|
|
|
|
m_navigatorsWidget->setSecondaryNavigatorVisible(true);
|
2023-02-03 17:14:53 +00:00
|
|
|
m_navigatorsWidget->followViewContainersGeometry(m_primaryViewContainer, m_secondaryViewContainer);
|
2020-09-20 16:53:59 +00:00
|
|
|
|
2014-07-02 13:30:37 +00:00
|
|
|
m_splitter->addWidget(m_secondaryViewContainer);
|
2020-10-28 16:52:29 +00:00
|
|
|
m_secondaryViewContainer->setActive(true);
|
2021-01-02 17:48:52 +00:00
|
|
|
|
|
|
|
if (animated == WithAnimation) {
|
|
|
|
m_secondaryViewContainer->setMinimumWidth(1);
|
|
|
|
splitterSizes.append(1);
|
|
|
|
m_splitter->setSizes(splitterSizes);
|
|
|
|
startExpandViewAnimation(m_secondaryViewContainer);
|
|
|
|
}
|
|
|
|
m_secondaryViewContainer->show();
|
2014-07-02 13:30:37 +00:00
|
|
|
} else {
|
2020-09-20 16:53:59 +00:00
|
|
|
m_navigatorsWidget->setSecondaryNavigatorVisible(false);
|
|
|
|
m_secondaryViewContainer->disconnectUrlNavigator();
|
|
|
|
|
2023-02-03 17:14:53 +00:00
|
|
|
DolphinViewContainer *view;
|
2019-02-16 15:08:12 +00:00
|
|
|
if (GeneralSettings::closeActiveSplitView()) {
|
|
|
|
view = activeViewContainer();
|
|
|
|
if (m_primaryViewActive) {
|
2020-09-20 16:53:59 +00:00
|
|
|
m_primaryViewContainer->disconnectUrlNavigator();
|
2023-02-03 17:14:53 +00:00
|
|
|
m_secondaryViewContainer->connectUrlNavigator(m_navigatorsWidget->primaryUrlNavigator());
|
2020-09-20 16:53:59 +00:00
|
|
|
|
2019-02-16 15:08:12 +00:00
|
|
|
// If the primary view is active, we have to swap the pointers
|
|
|
|
// because the secondary view will be the new primary view.
|
2023-01-16 16:44:25 +00:00
|
|
|
std::swap(m_primaryViewContainer, m_secondaryViewContainer);
|
2019-02-16 15:08:12 +00:00
|
|
|
m_primaryViewActive = false;
|
|
|
|
}
|
|
|
|
} else {
|
|
|
|
view = m_primaryViewActive ? m_secondaryViewContainer : m_primaryViewContainer;
|
|
|
|
if (!m_primaryViewActive) {
|
2020-09-20 16:53:59 +00:00
|
|
|
m_primaryViewContainer->disconnectUrlNavigator();
|
2023-02-03 17:14:53 +00:00
|
|
|
m_secondaryViewContainer->connectUrlNavigator(m_navigatorsWidget->primaryUrlNavigator());
|
2020-09-20 16:53:59 +00:00
|
|
|
|
2019-02-16 15:08:12 +00:00
|
|
|
// If the secondary view is active, we have to swap the pointers
|
|
|
|
// because the secondary view will be the new primary view.
|
2023-01-16 16:44:25 +00:00
|
|
|
std::swap(m_primaryViewContainer, m_secondaryViewContainer);
|
2019-02-16 15:08:12 +00:00
|
|
|
m_primaryViewActive = true;
|
|
|
|
}
|
2014-07-02 13:30:37 +00:00
|
|
|
}
|
|
|
|
m_primaryViewContainer->setActive(true);
|
2021-01-06 01:38:45 +00:00
|
|
|
m_navigatorsWidget->followViewContainersGeometry(m_primaryViewContainer, nullptr);
|
2021-01-02 17:48:52 +00:00
|
|
|
|
|
|
|
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);
|
|
|
|
}
|
2021-09-12 13:33:39 +00:00
|
|
|
|
|
|
|
m_primaryViewContainer->slotSplitTabDisabled();
|
2014-07-02 13:30:37 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2023-02-03 17:14:53 +00:00
|
|
|
DolphinViewContainer *DolphinTabPage::primaryViewContainer() const
|
2014-07-02 13:30:37 +00:00
|
|
|
{
|
|
|
|
return m_primaryViewContainer;
|
|
|
|
}
|
|
|
|
|
2023-02-03 17:14:53 +00:00
|
|
|
DolphinViewContainer *DolphinTabPage::secondaryViewContainer() const
|
2014-07-02 13:30:37 +00:00
|
|
|
{
|
|
|
|
return m_secondaryViewContainer;
|
|
|
|
}
|
|
|
|
|
2023-02-03 17:14:53 +00:00
|
|
|
DolphinViewContainer *DolphinTabPage::activeViewContainer() const
|
2014-07-02 13:30:37 +00:00
|
|
|
{
|
2023-02-03 17:14:53 +00:00
|
|
|
return m_primaryViewActive ? m_primaryViewContainer : m_secondaryViewContainer;
|
2014-07-02 13:30:37 +00:00
|
|
|
}
|
|
|
|
|
2023-04-22 19:21:44 +00:00
|
|
|
DolphinViewContainer *DolphinTabPage::inactiveViewContainer() const
|
|
|
|
{
|
|
|
|
if (!splitViewEnabled()) {
|
|
|
|
return nullptr;
|
|
|
|
}
|
|
|
|
|
|
|
|
return primaryViewActive() ? secondaryViewContainer() : primaryViewContainer();
|
|
|
|
}
|
|
|
|
|
2014-07-02 13:30:37 +00:00
|
|
|
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;
|
|
|
|
}
|
|
|
|
|
2020-09-20 16:53:59 +00:00
|
|
|
void DolphinTabPage::connectNavigators(DolphinNavigatorsWidgetAction *navigatorsWidget)
|
|
|
|
{
|
2020-11-19 21:22:27 +00:00
|
|
|
insertNavigatorsWidget(navigatorsWidget);
|
2020-09-20 16:53:59 +00:00
|
|
|
m_navigatorsWidget = navigatorsWidget;
|
|
|
|
auto primaryNavigator = navigatorsWidget->primaryUrlNavigator();
|
|
|
|
m_primaryViewContainer->connectUrlNavigator(primaryNavigator);
|
|
|
|
if (m_splitViewEnabled) {
|
|
|
|
auto secondaryNavigator = navigatorsWidget->secondaryUrlNavigator();
|
|
|
|
m_secondaryViewContainer->connectUrlNavigator(secondaryNavigator);
|
|
|
|
}
|
2023-02-03 17:14:53 +00:00
|
|
|
m_navigatorsWidget->followViewContainersGeometry(m_primaryViewContainer, m_secondaryViewContainer);
|
2020-09-20 16:53:59 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
void DolphinTabPage::disconnectNavigators()
|
|
|
|
{
|
|
|
|
m_navigatorsWidget = nullptr;
|
|
|
|
m_primaryViewContainer->disconnectUrlNavigator();
|
|
|
|
if (m_splitViewEnabled) {
|
|
|
|
m_secondaryViewContainer->disconnectUrlNavigator();
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2023-02-03 17:14:53 +00:00
|
|
|
void DolphinTabPage::insertNavigatorsWidget(DolphinNavigatorsWidgetAction *navigatorsWidget)
|
2020-11-19 21:22:27 +00:00
|
|
|
{
|
|
|
|
QGridLayout *gridLayout = static_cast<QGridLayout *>(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);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2023-02-03 17:14:53 +00:00
|
|
|
void DolphinTabPage::markUrlsAsSelected(const QList<QUrl> &urls)
|
2014-07-02 13:30:37 +00:00
|
|
|
{
|
|
|
|
m_primaryViewContainer->view()->markUrlsAsSelected(urls);
|
|
|
|
if (m_splitViewEnabled) {
|
|
|
|
m_secondaryViewContainer->view()->markUrlsAsSelected(urls);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2023-02-03 17:14:53 +00:00
|
|
|
void DolphinTabPage::markUrlAsCurrent(const QUrl &url)
|
2014-07-02 13:30:37 +00:00
|
|
|
{
|
|
|
|
m_primaryViewContainer->view()->markUrlAsCurrent(url);
|
|
|
|
if (m_splitViewEnabled) {
|
|
|
|
m_secondaryViewContainer->view()->markUrlAsCurrent(url);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
void DolphinTabPage::refreshViews()
|
|
|
|
{
|
|
|
|
m_primaryViewContainer->readSettings();
|
|
|
|
if (m_splitViewEnabled) {
|
|
|
|
m_secondaryViewContainer->readSettings();
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
QByteArray DolphinTabPage::saveState() const
|
|
|
|
{
|
|
|
|
QByteArray state;
|
|
|
|
QDataStream stream(&state, QIODevice::WriteOnly);
|
|
|
|
|
2014-08-20 21:06:39 +00:00
|
|
|
stream << quint32(2); // Tab state version
|
|
|
|
|
2014-07-02 13:30:37 +00:00
|
|
|
stream << m_splitViewEnabled;
|
|
|
|
|
|
|
|
stream << m_primaryViewContainer->url();
|
2020-08-27 16:55:18 +00:00
|
|
|
stream << m_primaryViewContainer->urlNavigatorInternalWithHistory()->isUrlEditable();
|
2014-08-20 21:06:39 +00:00
|
|
|
m_primaryViewContainer->view()->saveState(stream);
|
2014-07-02 13:30:37 +00:00
|
|
|
|
|
|
|
if (m_splitViewEnabled) {
|
|
|
|
stream << m_secondaryViewContainer->url();
|
2020-08-27 16:55:18 +00:00
|
|
|
stream << m_secondaryViewContainer->urlNavigatorInternalWithHistory()->isUrlEditable();
|
2014-08-20 21:06:39 +00:00
|
|
|
m_secondaryViewContainer->view()->saveState(stream);
|
2014-07-02 13:30:37 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
stream << m_primaryViewActive;
|
|
|
|
stream << m_splitter->saveState();
|
|
|
|
|
|
|
|
return state;
|
|
|
|
}
|
|
|
|
|
2023-02-03 17:14:53 +00:00
|
|
|
void DolphinTabPage::restoreState(const QByteArray &state)
|
2014-07-02 13:30:37 +00:00
|
|
|
{
|
2014-08-12 07:08:30 +00:00
|
|
|
if (state.isEmpty()) {
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
2014-07-02 13:30:37 +00:00
|
|
|
QByteArray sd = state;
|
|
|
|
QDataStream stream(&sd, QIODevice::ReadOnly);
|
|
|
|
|
2014-08-20 21:06:39 +00:00
|
|
|
// 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;
|
2021-01-02 17:48:52 +00:00
|
|
|
setSplitViewEnabled(isSplitViewEnabled, WithoutAnimation);
|
2014-08-20 21:06:39 +00:00
|
|
|
|
2014-10-21 19:18:43 +00:00
|
|
|
QUrl primaryUrl;
|
2014-08-20 21:06:39 +00:00
|
|
|
stream >> primaryUrl;
|
|
|
|
m_primaryViewContainer->setUrl(primaryUrl);
|
|
|
|
bool primaryUrlEditable;
|
|
|
|
stream >> primaryUrlEditable;
|
2020-08-27 16:55:18 +00:00
|
|
|
m_primaryViewContainer->urlNavigatorInternalWithHistory()->setUrlEditable(primaryUrlEditable);
|
2014-08-20 21:06:39 +00:00
|
|
|
m_primaryViewContainer->view()->restoreState(stream);
|
|
|
|
|
|
|
|
if (isSplitViewEnabled) {
|
2014-10-21 19:18:43 +00:00
|
|
|
QUrl secondaryUrl;
|
2014-08-20 21:06:39 +00:00
|
|
|
stream >> secondaryUrl;
|
|
|
|
m_secondaryViewContainer->setUrl(secondaryUrl);
|
|
|
|
bool secondaryUrlEditable;
|
|
|
|
stream >> secondaryUrlEditable;
|
2020-08-27 16:55:18 +00:00
|
|
|
m_secondaryViewContainer->urlNavigatorInternalWithHistory()->setUrlEditable(secondaryUrlEditable);
|
2014-08-20 21:06:39 +00:00
|
|
|
m_secondaryViewContainer->view()->restoreState(stream);
|
|
|
|
}
|
|
|
|
|
|
|
|
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);
|
|
|
|
}
|
|
|
|
|
2017-05-22 17:35:29 +00:00
|
|
|
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);
|
|
|
|
}
|
|
|
|
|
2021-01-02 17:48:52 +00:00
|
|
|
void DolphinTabPage::slotAnimationFinished()
|
|
|
|
{
|
|
|
|
for (int i = 0; i < m_splitter->count(); ++i) {
|
|
|
|
QWidget *viewContainer = m_splitter->widget(i);
|
2023-02-03 17:14:53 +00:00
|
|
|
if (viewContainer != m_primaryViewContainer && viewContainer != m_secondaryViewContainer) {
|
2021-01-02 17:48:52 +00:00
|
|
|
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;
|
|
|
|
}
|
|
|
|
|
2023-02-03 17:14:53 +00:00
|
|
|
void DolphinTabPage::slotAnimationValueChanged(const QVariant &value)
|
2021-01-02 17:48:52 +00:00
|
|
|
{
|
|
|
|
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<QWidget *> widgetsToRemove;
|
|
|
|
const QList<int> oldSplitterSizes = m_splitter->sizes();
|
|
|
|
QList<int> 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) {
|
2023-02-03 17:14:53 +00:00
|
|
|
if (m_splitter->widget(i) == m_primaryViewContainer || m_splitter->widget(i) == m_secondaryViewContainer) {
|
2021-01-02 17:48:52 +00:00
|
|
|
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();
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2014-07-02 13:30:37 +00:00
|
|
|
void DolphinTabPage::slotViewActivated()
|
|
|
|
{
|
2023-02-03 17:14:53 +00:00
|
|
|
const DolphinView *oldActiveView = activeViewContainer()->view();
|
2014-07-02 13:30:37 +00:00
|
|
|
|
|
|
|
// Set the view, which was active before, to inactive
|
2017-05-22 17:35:29 +00:00
|
|
|
// 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;
|
2018-04-25 11:42:18 +00:00
|
|
|
if (m_secondaryViewContainer) {
|
|
|
|
m_secondaryViewContainer->setActive(false);
|
|
|
|
}
|
2017-05-22 17:35:29 +00:00
|
|
|
}
|
2014-07-02 13:30:37 +00:00
|
|
|
}
|
|
|
|
|
2023-02-03 17:14:53 +00:00
|
|
|
const DolphinView *newActiveView = activeViewContainer()->view();
|
2014-07-02 13:30:37 +00:00
|
|
|
|
2019-01-14 01:55:07 +00:00
|
|
|
if (newActiveView == oldActiveView) {
|
|
|
|
return;
|
2014-07-02 13:30:37 +00:00
|
|
|
}
|
|
|
|
|
2023-02-03 17:14:53 +00:00
|
|
|
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);
|
2020-10-23 17:51:33 +00:00
|
|
|
Q_EMIT activeViewChanged(activeViewContainer());
|
|
|
|
Q_EMIT activeViewUrlChanged(activeViewContainer()->url());
|
2014-07-02 13:30:37 +00:00
|
|
|
}
|
|
|
|
|
2023-02-03 17:14:53 +00:00
|
|
|
void DolphinTabPage::slotViewUrlRedirection(const QUrl &oldUrl, const QUrl &newUrl)
|
2014-08-13 20:06:28 +00:00
|
|
|
{
|
2019-11-09 21:06:39 +00:00
|
|
|
Q_UNUSED(oldUrl)
|
2014-08-13 20:06:28 +00:00
|
|
|
|
2020-10-23 17:51:33 +00:00
|
|
|
Q_EMIT activeViewUrlChanged(newUrl);
|
2014-08-13 20:06:28 +00:00
|
|
|
}
|
|
|
|
|
2016-07-31 17:16:18 +00:00
|
|
|
void DolphinTabPage::switchActiveView()
|
|
|
|
{
|
|
|
|
if (!m_splitViewEnabled) {
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
if (m_primaryViewActive) {
|
2023-02-03 17:14:53 +00:00
|
|
|
m_secondaryViewContainer->setActive(true);
|
2016-07-31 17:16:18 +00:00
|
|
|
} else {
|
2023-02-03 17:14:53 +00:00
|
|
|
m_primaryViewContainer->setActive(true);
|
2016-07-31 17:16:18 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2023-02-03 17:14:53 +00:00
|
|
|
DolphinViewContainer *DolphinTabPage::createViewContainer(const QUrl &url) const
|
2014-07-02 13:30:37 +00:00
|
|
|
{
|
2023-02-03 17:14:53 +00:00
|
|
|
DolphinViewContainer *container = new DolphinViewContainer(url, m_splitter);
|
2014-07-02 13:30:37 +00:00
|
|
|
container->setActive(false);
|
|
|
|
|
2023-02-03 17:14:53 +00:00
|
|
|
const DolphinView *view = container->view();
|
|
|
|
connect(view, &DolphinView::activated, this, &DolphinTabPage::slotViewActivated);
|
2014-07-02 13:30:37 +00:00
|
|
|
|
2023-02-03 17:14:53 +00:00
|
|
|
connect(view, &DolphinView::toggleActiveViewRequested, this, &DolphinTabPage::switchActiveView);
|
2016-07-31 17:16:18 +00:00
|
|
|
|
2014-07-02 13:30:37 +00:00
|
|
|
return container;
|
|
|
|
}
|
2021-01-02 17:48:52 +00:00
|
|
|
|
|
|
|
void DolphinTabPage::startExpandViewAnimation(DolphinViewContainer *expandingContainer)
|
|
|
|
{
|
|
|
|
Q_CHECK_PTR(expandingContainer);
|
2023-02-03 17:14:53 +00:00
|
|
|
Q_ASSERT(expandingContainer == m_primaryViewContainer || expandingContainer == m_secondaryViewContainer);
|
2021-01-02 17:48:52 +00:00
|
|
|
m_expandingContainer = expandingContainer;
|
|
|
|
|
|
|
|
m_expandViewAnimation = new QVariantAnimation(m_splitter);
|
2023-02-03 17:14:53 +00:00
|
|
|
m_expandViewAnimation->setDuration(2 * style()->styleHint(QStyle::SH_Widget_Animation_Duration, nullptr, this) * GlobalConfig::animationDurationFactor());
|
2021-01-02 17:48:52 +00:00
|
|
|
for (int i = 0; i < m_splitter->count(); ++i) {
|
|
|
|
m_splitter->widget(i)->setMinimumWidth(1);
|
|
|
|
}
|
2023-02-03 17:14:53 +00:00
|
|
|
connect(m_expandViewAnimation, &QAbstractAnimation::finished, this, &DolphinTabPage::slotAnimationFinished);
|
|
|
|
connect(m_expandViewAnimation, &QVariantAnimation::valueChanged, this, &DolphinTabPage::slotAnimationValueChanged);
|
2021-01-02 17:48:52 +00:00
|
|
|
|
|
|
|
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);
|
|
|
|
}
|
2021-08-30 14:18:21 +00:00
|
|
|
|
|
|
|
DolphinTabPageSplitterHandle::DolphinTabPageSplitterHandle(Qt::Orientation orientation, QSplitter *parent)
|
|
|
|
: QSplitterHandle(orientation, parent)
|
|
|
|
, m_mouseReleaseWasReceived(false)
|
2023-02-03 17:14:53 +00:00
|
|
|
{
|
|
|
|
}
|
2021-08-30 14:18:21 +00:00
|
|
|
|
|
|
|
bool DolphinTabPageSplitterHandle::event(QEvent *event)
|
|
|
|
{
|
|
|
|
switch (event->type()) {
|
|
|
|
case QEvent::MouseButtonPress:
|
|
|
|
m_mouseReleaseWasReceived = false;
|
|
|
|
break;
|
|
|
|
case QEvent::MouseButtonRelease:
|
|
|
|
if (m_mouseReleaseWasReceived) {
|
|
|
|
resetSplitterSizes();
|
|
|
|
}
|
|
|
|
m_mouseReleaseWasReceived = !m_mouseReleaseWasReceived;
|
|
|
|
break;
|
|
|
|
case QEvent::MouseButtonDblClick:
|
|
|
|
m_mouseReleaseWasReceived = false;
|
|
|
|
resetSplitterSizes();
|
|
|
|
break;
|
|
|
|
default:
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
return QSplitterHandle::event(event);
|
|
|
|
}
|
|
|
|
|
|
|
|
void DolphinTabPageSplitterHandle::resetSplitterSizes()
|
|
|
|
{
|
|
|
|
QList<int> splitterSizes = splitter()->sizes();
|
|
|
|
std::fill(splitterSizes.begin(), splitterSizes.end(), 0);
|
|
|
|
splitter()->setSizes(splitterSizes);
|
|
|
|
}
|
|
|
|
|
|
|
|
DolphinTabPageSplitter::DolphinTabPageSplitter(Qt::Orientation orientation, QWidget *parent)
|
|
|
|
: QSplitter(orientation, parent)
|
2023-02-03 17:14:53 +00:00
|
|
|
{
|
|
|
|
}
|
2021-08-30 14:18:21 +00:00
|
|
|
|
2023-02-03 17:14:53 +00:00
|
|
|
QSplitterHandle *DolphinTabPageSplitter::createHandle()
|
2021-08-30 14:18:21 +00:00
|
|
|
{
|
|
|
|
return new DolphinTabPageSplitterHandle(orientation(), this);
|
|
|
|
}
|
2023-07-04 20:07:48 +00:00
|
|
|
|
|
|
|
#include "moc_dolphintabpage.cpp"
|