-/***************************************************************************
- * Copyright (C) 2014 by Emmanuel Pescosta <emmanuelpescosta099@gmail.com> *
- * *
- * 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 <emmanuelpescosta099@gmail.com>
+ *
+ * SPDX-License-Identifier: GPL-2.0-or-later
+ */
#include "dolphintabpage.h"
-#include "dolphinviewcontainer.h"
#include "dolphin_generalsettings.h"
+#include "dolphinviewcontainer.h"
#include <QSplitter>
+#include <QGridLayout>
+#include <QWidgetAction>
-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);
+ 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);
- connect(m_primaryViewContainer->view(), SIGNAL(urlChanged(KUrl)),
- this, SIGNAL(activeViewUrlChanged(KUrl)));
- connect(m_primaryViewContainer->view(), SIGNAL(redirection(KUrl,KUrl)),
- this, SLOT(slotViewUrlRedirection(KUrl,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();
}
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);
- 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_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();
return selectedItemsCount;
}
-void DolphinTabPage::markUrlsAsSelected(const QList<KUrl>& urls)
+void DolphinTabPage::connectNavigators(DolphinNavigatorsWidgetAction *navigatorsWidget)
{
- m_primaryViewContainer->view()->markUrlsAsSelected(urls);
+ insertNavigatorsWidget(navigatorsWidget);
+ m_navigatorsWidget = navigatorsWidget;
+ auto primaryNavigator = navigatorsWidget->primaryUrlNavigator();
+ m_primaryViewContainer->connectUrlNavigator(primaryNavigator);
if (m_splitViewEnabled) {
- m_secondaryViewContainer->view()->markUrlsAsSelected(urls);
+ auto secondaryNavigator = navigatorsWidget->secondaryUrlNavigator();
+ 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();
+ }
+}
+
+bool DolphinTabPage::eventFilter(QObject *watched, QEvent *event)
+{
+ if (event->type() == QEvent::Resize && m_navigatorsWidget) {
+ resizeNavigators();
+ return false;
+ }
+ return QWidget::eventFilter(watched, event);
+}
+
+void DolphinTabPage::insertNavigatorsWidget(DolphinNavigatorsWidgetAction* navigatorsWidget)
+{
+ 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);
}
}
-void DolphinTabPage::setPlacesSelectorVisible(bool visible)
+
+void DolphinTabPage::resizeNavigators() const
{
- m_primaryViewContainer->urlNavigator()->setPlacesSelectorVisible(visible);
+ 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<QUrl>& 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);
}
}
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 >> 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 >> 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);
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);
}
stream >> m_primaryViewActive;
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)));
- disconnect(oldActiveView, SIGNAL(redirection(KUrl,KUrl)),
- this, SLOT(slotViewUrlRedirection(KUrl,KUrl)));
- connect(newActiveView, SIGNAL(urlChanged(KUrl)),
- this, SIGNAL(activeViewUrlChanged(KUrl)));
- connect(newActiveView, SIGNAL(redirection(KUrl,KUrl)),
- this, SLOT(slotViewUrlRedirection(KUrl,KUrl)));
+ 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 KUrl& oldUrl, const KUrl& newUrl)
+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()
+{
+ if (!m_splitViewEnabled) {
+ return;
+ }
+ if (m_primaryViewActive) {
+ m_secondaryViewContainer->setActive(true);
+ } else {
+ m_primaryViewContainer->setActive(true);
+ }
}
-DolphinViewContainer* DolphinTabPage::createViewContainer(const KUrl& url) const
+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;
}
projects / dolphin.git / blobdiff