#include "dolphintabbar.h"
#include "dolphintabpage.h"
#include "dolphinviewcontainer.h"
-#include "dolphin_generalsettings.h"
-#include "views/draganddrophelper.h"
-#include <QApplication>
#include <KConfigGroup>
-#include <KIcon>
#include <KRun>
+#include <KShell>
+#include <kio/global.h>
+
+#include <QApplication>
+#include <QDropEvent>
DolphinTabWidget::DolphinTabWidget(QWidget* parent) :
QTabWidget(parent),
- m_placesSelectorVisible(true)
+ m_placesSelectorVisible(true),
+ m_lastViewedTab(0)
{
- connect(this, SIGNAL(tabCloseRequested(int)),
- this, SLOT(closeTab(int)));
- connect(this, SIGNAL(currentChanged(int)),
- this, SLOT(currentTabChanged(int)));
+ connect(this, &DolphinTabWidget::tabCloseRequested,
+ this, static_cast<void (DolphinTabWidget::*)(int)>(&DolphinTabWidget::closeTab));
+ connect(this, &DolphinTabWidget::currentChanged,
+ this, &DolphinTabWidget::currentTabChanged);
DolphinTabBar* tabBar = new DolphinTabBar(this);
- connect(tabBar, SIGNAL(openNewActivatedTab(int)),
- this, SLOT(openNewActivatedTab(int)));
- connect(tabBar, SIGNAL(tabDropEvent(int,QDropEvent*)),
- this, SLOT(tabDropEvent(int,QDropEvent*)));
- connect(tabBar, SIGNAL(tabDetachRequested(int)),
- this, SLOT(detachTab(int)));
+ connect(tabBar, &DolphinTabBar::openNewActivatedTab,
+ this, static_cast<void (DolphinTabWidget::*)(int)>(&DolphinTabWidget::openNewActivatedTab));
+ connect(tabBar, &DolphinTabBar::tabDropEvent,
+ this, &DolphinTabWidget::tabDropEvent);
+ connect(tabBar, &DolphinTabBar::tabDetachRequested,
+ this, &DolphinTabWidget::detachTab);
tabBar->hide();
setTabBar(tabBar);
return tabPageAt(currentIndex());
}
+DolphinTabPage* DolphinTabWidget::nextTabPage() const
+{
+ const int index = currentIndex() + 1;
+ return tabPageAt(index < count() ? index : 0);
+}
+
+DolphinTabPage* DolphinTabWidget::prevTabPage() const
+{
+ const int index = currentIndex() - 1;
+ return tabPageAt(index >= 0 ? index : (count() - 1));
+}
+
DolphinTabPage* DolphinTabWidget::tabPageAt(const int index) const
{
return static_cast<DolphinTabPage*>(widget(index));
for (int i = 0; i < tabCount; ++i) {
const DolphinTabPage* tabPage = tabPageAt(i);
- group.writeEntry("Tab " % QString::number(i), tabPage->saveState());
+ group.writeEntry("Tab Data " % QString::number(i), tabPage->saveState());
}
}
if (i >= count()) {
openNewActivatedTab();
}
- const QByteArray state = group.readEntry("Tab " % QString::number(i), QByteArray());
- tabPageAt(i)->restoreState(state);
+ if (group.hasKey("Tab Data " % QString::number(i))) {
+ // Tab state created with Dolphin > 4.14.x
+ const QByteArray state = group.readEntry("Tab Data " % QString::number(i), QByteArray());
+ tabPageAt(i)->restoreState(state);
+ } else {
+ // Tab state created with Dolphin <= 4.14.x
+ const QByteArray state = group.readEntry("Tab " % QString::number(i), QByteArray());
+ tabPageAt(i)->restoreStateV1(state);
+ }
}
const int index = group.readEntry("Active Tab Index", 0);
}
}
-void DolphinTabWidget::openNewActivatedTab(const KUrl& primaryUrl, const KUrl& secondaryUrl)
+void DolphinTabWidget::openNewActivatedTab(const QUrl& primaryUrl, const QUrl& secondaryUrl)
{
openNewTab(primaryUrl, secondaryUrl);
setCurrentIndex(count() - 1);
}
-void DolphinTabWidget::openNewTab(const KUrl& primaryUrl, const KUrl& secondaryUrl)
+void DolphinTabWidget::openNewTab(const QUrl& primaryUrl, const QUrl& secondaryUrl)
{
QWidget* focusWidget = QApplication::focusWidget();
DolphinTabPage* tabPage = new DolphinTabPage(primaryUrl, secondaryUrl, this);
tabPage->setPlacesSelectorVisible(m_placesSelectorVisible);
- connect(tabPage, SIGNAL(activeViewChanged(DolphinViewContainer*)),
- this, SIGNAL(activeViewChanged(DolphinViewContainer*)));
- connect(tabPage, SIGNAL(activeViewUrlChanged(KUrl)),
- this, SLOT(tabUrlChanged(KUrl)));
- addTab(tabPage, KIcon(KMimeType::iconNameForUrl(primaryUrl)), tabName(primaryUrl));
+ connect(tabPage, &DolphinTabPage::activeViewChanged,
+ this, &DolphinTabWidget::activeViewChanged);
+ connect(tabPage, &DolphinTabPage::activeViewUrlChanged,
+ this, &DolphinTabWidget::tabUrlChanged);
+ addTab(tabPage, QIcon::fromTheme(KIO::iconNameForUrl(primaryUrl)), tabName(primaryUrl));
if (focusWidget) {
// The DolphinViewContainer grabbed the keyboard focus. As the tab is opened
}
}
-void DolphinTabWidget::openDirectories(const QList<KUrl>& dirs)
+void DolphinTabWidget::openDirectories(const QList<QUrl>& dirs, bool splitView)
{
- const bool hasSplitView = GeneralSettings::splitView();
+ Q_ASSERT(dirs.size() > 0);
- // Open each directory inside a new tab. If the "split view" option has been enabled,
- // always show two directories within one tab.
- QList<KUrl>::const_iterator it = dirs.constBegin();
+ QList<QUrl>::const_iterator it = dirs.constBegin();
while (it != dirs.constEnd()) {
- const KUrl& primaryUrl = *(it++);
- if (hasSplitView && (it != dirs.constEnd())) {
- const KUrl& secondaryUrl = *(it++);
+ const QUrl& primaryUrl = *(it++);
+ if (splitView && (it != dirs.constEnd())) {
+ const QUrl& secondaryUrl = *(it++);
openNewTab(primaryUrl, secondaryUrl);
} else {
openNewTab(primaryUrl);
}
}
-void DolphinTabWidget::openFiles(const QList<KUrl>& files)
+void DolphinTabWidget::openFiles(const QList<QUrl>& files, bool splitView)
{
- if (files.isEmpty()) {
- return;
- }
+ Q_ASSERT(files.size() > 0);
// Get all distinct directories from 'files' and open a tab
// for each directory. If the "split view" option is enabled, two
// directories are shown inside one tab (see openDirectories()).
- QList<KUrl> dirs;
- foreach (const KUrl& url, files) {
- const KUrl dir(url.directory());
+ QList<QUrl> dirs;
+ foreach (const QUrl& url, files) {
+ const QUrl dir(url.adjusted(QUrl::RemoveFilename));
if (!dirs.contains(dir)) {
dirs.append(dir);
}
}
const int oldTabCount = count();
- openDirectories(dirs);
+ openDirectories(dirs, splitView);
const int tabCount = count();
// Select the files. Although the files can be split between several
}
DolphinTabPage* tabPage = tabPageAt(index);
- if (tabPage->splitViewEnabled()) {
- emit rememberClosedTab(tabPage->primaryViewContainer()->url(),
- tabPage->secondaryViewContainer()->url());
- } else {
- emit rememberClosedTab(tabPage->primaryViewContainer()->url(), KUrl());
- }
+ emit rememberClosedTab(tabPage->activeViewContainer()->url(), tabPage->saveState());
removeTab(index);
tabPage->deleteLater();
}
}
+void DolphinTabWidget::restoreClosedTab(const QByteArray& state)
+{
+ openNewActivatedTab();
+ currentTabPage()->restoreState(state);
+}
+
void DolphinTabWidget::detachTab(int index)
{
Q_ASSERT(index >= 0);
- const QString separator(QLatin1Char(' '));
- QString command = QLatin1String("dolphin");
+ QStringList args;
const DolphinTabPage* tabPage = tabPageAt(index);
- command += separator + tabPage->primaryViewContainer()->url().url();
+ args << tabPage->primaryViewContainer()->url().url();
if (tabPage->splitViewEnabled()) {
- command += separator + tabPage->secondaryViewContainer()->url().url();
- command += separator + QLatin1String("-split");
+ args << tabPage->secondaryViewContainer()->url().url();
+ args << QStringLiteral("--split");
}
+ const QString command = QStringLiteral("dolphin %1").arg(KShell::joinArgs(args));
KRun::runCommand(command, this);
closeTab(index);
void DolphinTabWidget::tabDropEvent(int index, QDropEvent* event)
{
if (index >= 0) {
- const DolphinView* view = tabPageAt(index)->activeViewContainer()->view();
-
- QString error;
- DragAndDropHelper::dropUrls(view->rootItem(), view->url(), event, error);
- if (!error.isEmpty()) {
- currentTabPage()->activeViewContainer()->showMessage(error, DolphinViewContainer::Error);
- }
+ DolphinView* view = tabPageAt(index)->activeViewContainer()->view();
+ view->dropUrls(view->url(), event, view);
}
}
-void DolphinTabWidget::tabUrlChanged(const KUrl& url)
+void DolphinTabWidget::tabUrlChanged(const QUrl& url)
{
const int index = indexOf(qobject_cast<QWidget*>(sender()));
if (index >= 0) {
tabBar()->setTabText(index, tabName(url));
- tabBar()->setTabIcon(index, KIcon(KMimeType::iconNameForUrl(url)));
+ tabBar()->setTabIcon(index, QIcon::fromTheme(KIO::iconNameForUrl(url)));
+
+ // Emit the currentUrlChanged signal if the url of the current tab has been changed.
+ if (index == currentIndex()) {
+ emit currentUrlChanged(url);
+ }
}
}
void DolphinTabWidget::currentTabChanged(int index)
{
- emit activeViewChanged(tabPageAt(index)->activeViewContainer());
+ // last-viewed tab deactivation
+ if (DolphinTabPage* tabPage = tabPageAt(m_lastViewedTab)) {
+ tabPage->setActive(false);
+ }
+ DolphinTabPage* tabPage = tabPageAt(index);
+ DolphinViewContainer* viewContainer = tabPage->activeViewContainer();
+ emit activeViewChanged(viewContainer);
+ emit currentUrlChanged(viewContainer->url());
+ tabPage->setActive(true);
+ m_lastViewedTab = index;
}
void DolphinTabWidget::tabInserted(int index)
emit tabCountChanged(count());
}
-QString DolphinTabWidget::tabName(const KUrl& url) const
+QString DolphinTabWidget::tabName(const QUrl& url) const
{
QString name;
- if (url.equals(KUrl("file:///"))) {
+ if (url == QUrl(QStringLiteral("file:///"))) {
name = '/';
} else {
- name = url.fileName();
+ name = url.adjusted(QUrl::StripTrailingSlash).fileName();
if (name.isEmpty()) {
- name = url.protocol();
+ name = url.scheme();
} else {
// Make sure that a '&' inside the directory name is displayed correctly
// and not misinterpreted as a keyboard shortcut in QTabBar::setTabText()
- name.replace('&', "&&");
+ name.replace('&', QLatin1String("&&"));
}
}
return name;
projects / dolphin.git / blobdiff