Fix a crash and extract unrelated changes

[dolphin.git] / src / dolphintabpage.cpp

diff --git a/src/dolphintabpage.cpp b/src/dolphintabpage.cpp
index 3d1ba5a3e85babcff66bde960ada232dfbc51063..d196508a8756e71a9e44054f22a59bb1dd9d6e92 100644 (file)
--- a/src/dolphintabpage.cpp
+++ b/src/dolphintabpage.cpp
@@ -1,59 +1,52 @@
-/***************************************************************************
- * 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 "dolphintabpage.h"
 

-#include "dolphinviewcontainer.h"

 #include "dolphin_generalsettings.h"
 #include "dolphin_generalsettings.h"

+#include "dolphinviewcontainer.h"

 
 #include <QSplitter>
 
 #include <QSplitter>

+#include <QVBoxLayout>

 
 

-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),
     QWidget(parent),
     m_primaryViewActive(true),

-    m_splitViewEnabled(false)
+    m_splitViewEnabled(false),
+    m_active(true)

 {
     QVBoxLayout* layout = new QVBoxLayout(this);
     layout->setSpacing(0);
 {
     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);
 
     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);
     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(), 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_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;
     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 = createViewContainer(url);
         m_splitter->addWidget(m_secondaryViewContainer);

+        m_secondaryViewContainer->installEventFilter(this);

         m_secondaryViewContainer->show();
     }
 
         m_secondaryViewContainer->show();
     }
 


@@ -70,28 +63,56 @@ bool DolphinTabPage::splitViewEnabled() const
     return m_splitViewEnabled;
 }
 
     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) {
 {
     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);
 
             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_splitter->addWidget(m_secondaryViewContainer);

+            m_secondaryViewContainer->installEventFilter(this);

             m_secondaryViewContainer->show();
             m_secondaryViewContainer->setActive(true);
         } else {
             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();
             }
             m_primaryViewContainer->setActive(true);
             view->close();


@@ -134,27 +155,65 @@ int DolphinTabPage::selectedItemsCount() const
     return selectedItemsCount;
 }
 
     return selectedItemsCount;
 }
 

-void DolphinTabPage::markUrlsAsSelected(const QList<KUrl>& 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) {
     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) {
     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;

 }
 
 }
 

-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) {
     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);

     }
 }
 
     }
 }
 


@@ -171,14 +230,18 @@ QByteArray DolphinTabPage::saveState() const
     QByteArray state;
     QDataStream stream(&state, QIODevice::WriteOnly);
 
     QByteArray state;
     QDataStream stream(&state, QIODevice::WriteOnly);
 

+    stream << quint32(2); // Tab state version
+

     stream << m_splitViewEnabled;
 
     stream << m_primaryViewContainer->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();
 
     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;
     }
 
     stream << m_primaryViewActive;


@@ -196,24 +259,78 @@ void DolphinTabPage::restoreState(const QByteArray& state)
     QByteArray sd = state;
     QDataStream stream(&sd, QIODevice::ReadOnly);
 
     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);
+
+    QUrl primaryUrl;
+    stream >> primaryUrl;
+    m_primaryViewContainer->setUrl(primaryUrl);
+    bool primaryUrlEditable;
+    stream >> primaryUrlEditable;
+    m_primaryViewContainer->urlNavigatorInternalWithHistory()->setUrlEditable(primaryUrlEditable);
+    m_primaryViewContainer->view()->restoreState(stream);
+
+    if (isSplitViewEnabled) {
+        QUrl secondaryUrl;
+        stream >> secondaryUrl;
+        m_secondaryViewContainer->setUrl(secondaryUrl);
+        bool secondaryUrlEditable;
+        stream >> 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;
+    stream >> splitterState;
+    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);
 
     bool isSplitViewEnabled = false;
     stream >> isSplitViewEnabled;
     setSplitViewEnabled(isSplitViewEnabled);
 

-    KUrl primaryUrl;
+    QUrl primaryUrl;

     stream >> primaryUrl;
     m_primaryViewContainer->setUrl(primaryUrl);
     bool primaryUrlEditable;
     stream >> primaryUrlEditable;
     stream >> primaryUrl;
     m_primaryViewContainer->setUrl(primaryUrl);
     bool primaryUrlEditable;
     stream >> primaryUrlEditable;

-    m_primaryViewContainer->urlNavigator()->setUrlEditable(primaryUrlEditable);
+    m_primaryViewContainer->urlNavigatorInternalWithHistory()->setUrlEditable(primaryUrlEditable);

 
     if (isSplitViewEnabled) {
 
     if (isSplitViewEnabled) {

-        KUrl secondaryUrl;
+        QUrl secondaryUrl;

         stream >> secondaryUrl;
         m_secondaryViewContainer->setUrl(secondaryUrl);
         bool secondaryUrlEditable;
         stream >> secondaryUrlEditable;
         stream >> secondaryUrl;
         m_secondaryViewContainer->setUrl(secondaryUrl);
         bool secondaryUrlEditable;
         stream >> secondaryUrlEditable;

-        m_secondaryViewContainer->urlNavigator()->setUrlEditable(secondaryUrlEditable);
+        m_secondaryViewContainer->urlNavigatorInternalWithHistory()->setUrlEditable(secondaryUrlEditable);

     }
 
     stream >> m_primaryViewActive;
     }
 
     stream >> m_primaryViewActive;


@@ -229,51 +346,84 @@ void DolphinTabPage::restoreState(const QByteArray& state)
     m_splitter->restoreState(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
 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();
 
     }
 
     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)
+
+    Q_EMIT activeViewUrlChanged(newUrl);
+}

 
 

-    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();
 {
     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;
 }
 
     return container;
 }