typedef struct {
const char *description;
const char *regExp;
int cursorAdjustment;
} term;
static const term items[] = {
{ I18N_NOOP("Any Character"), ".", 0 },
{ I18N_NOOP("Start of Line"), "^", 0 },
{ I18N_NOOP("End of Line"), "$", 0 },
{ I18N_NOOP("Set of Characters"), "[]", -1 },
{ I18N_NOOP("Repeats, Zero or More Times"), "*", 0 },
{ I18N_NOOP("Repeats, One or More Times"), "+", 0 },
{ I18N_NOOP("Optional"), "?", 0 },
{ I18N_NOOP("Escape"), "\\", 0 },
{ I18N_NOOP("TAB"), "\\t", 0 },
{ I18N_NOOP("Newline"), "\\n", 0 },
{ I18N_NOOP("Carriage Return"), "\\r", 0 },
{ I18N_NOOP("White Space"), "\\s", 0 },
{ I18N_NOOP("Digit"), "\\d", 0 },
};
class RegExpAction : public QAction
{
public:
RegExpAction(QObject *parent, const QString &text, const QString ®Exp, int cursor)
: QAction(text, parent), mText(text), mRegExp(regExp), mCursor(cursor) {
}
QString text() const {
return mText;
}
QString regExp() const {
return mRegExp;
}
int cursor() const {
return mCursor;
}
private:
QString mText;
QString mRegExp;
int mCursor;
};
GeneralFilter::GeneralFilter(FilterTabs *tabs, int properties, QWidget *parent,
QStringList extraOptions) :
QWidget(parent),
profileManager(nullptr), fltTabs(tabs)
{
auto *filterLayout = new QGridLayout(this);
filterLayout->setSpacing(6);
filterLayout->setContentsMargins(11, 11, 11, 11);
this->properties = properties;
// Options for name filtering
auto *nameGroup = new QGroupBox(this);
nameGroup->setTitle(i18n("File Name"));
auto *nameGroupLayout = new QGridLayout(nameGroup);
nameGroupLayout->setAlignment(Qt::AlignTop);
nameGroupLayout->setSpacing(6);
nameGroupLayout->setContentsMargins(11, 11, 11, 11);
searchForCase = new QCheckBox(nameGroup);
searchForCase->setText(i18n("&Case sensitive"));
searchForCase->setChecked(false);
nameGroupLayout->addWidget(searchForCase, 1, 2);
QLabel *searchForLabel = new QLabel(nameGroup);
searchForLabel->setText(i18n("Search &for:"));
nameGroupLayout->addWidget(searchForLabel, 0, 0);
searchFor = new KrHistoryComboBox(false, nameGroup/*, "searchFor"*/);
QSizePolicy searchForPolicy(QSizePolicy::Expanding, QSizePolicy::Fixed);
searchForPolicy.setHeightForWidth(searchFor->sizePolicy().hasHeightForWidth());
searchFor->setSizePolicy(searchForPolicy);
searchFor->setEditable(true);
searchFor->setDuplicatesEnabled(false);
searchFor->setMaxCount(25);
searchFor->setMinimumContentsLength(10);
searchForLabel->setBuddy(searchFor);
nameGroupLayout->addWidget(searchFor, 0, 1, 1, 2);
const QString s = "
"
+ i18n("The filename filtering criteria is defined here.
"
"You can make use of wildcards. Multiple patterns are separated by "
"space (means logical OR) and patterns are excluded from the search "
"using the pipe symbol.
"
"If the pattern is ended with a slash (*pattern*/), "
"that means that pattern relates to recursive search of folders."
"
pattern - means to search those files/folders "
"that name is pattern, recursive search goes through all "
"subfolders independently of the value of patternpattern/ - means to search all files/folders, but "
"recursive search goes through/excludes the folders that name is "
"pattern
"
"It is allowed to use quotation marks for names that contain space."
" Filter \"Program Files\" searches out those "
"files/folders that name is Program Files.
"
"Examples:
"
"*.o*.h *.c\?\?*.cpp *.h | *.moc.cpp* | .svn/ .git/
"
"Note: the search term 'text' is equivalent to "
"'*text*'.
");
searchFor->setWhatsThis(s);
searchForLabel->setWhatsThis(s);
QLabel *searchType = new QLabel(nameGroup);
searchType->setText(i18n("&Of type:"));
nameGroupLayout->addWidget(searchType, 1, 0);
ofType = new KComboBox(false, nameGroup);
ofType->setObjectName("ofType");
QSizePolicy ofTypePolicy(QSizePolicy::Expanding, QSizePolicy::Fixed);
ofTypePolicy.setHeightForWidth(ofType->sizePolicy().hasHeightForWidth());
ofType->setSizePolicy(ofTypePolicy);
ofType->setEditable(false);
searchType->setBuddy(ofType);
ofType->addItem(i18n("All Files"));
ofType->addItem(i18n("Archives"));
ofType->addItem(i18n("Folders"));
ofType->addItem(i18n("Image Files"));
ofType->addItem(i18n("Text Files"));
ofType->addItem(i18n("Video Files"));
ofType->addItem(i18n("Audio Files"));
connect(ofType, QOverload::of(&KComboBox::currentIndexChanged), this, &GeneralFilter::slotDisable);
nameGroupLayout->addWidget(ofType, 1, 1);
filterLayout->addWidget(nameGroup, 0, 0);
middleLayout = new QHBoxLayout();
middleLayout->setSpacing(6);
middleLayout->setContentsMargins(0, 0, 0, 0);
if (properties & FilterTabs::HasProfileHandler) {
// The profile handler
auto *profileHandler = new QGroupBox(this);
profileHandler->setTitle(i18n("&Profile handler"));
auto *profileLayout = new QGridLayout(profileHandler);
profileLayout->setAlignment(Qt::AlignTop);
profileLayout->setSpacing(6);
profileLayout->setContentsMargins(11, 11, 11, 11);
profileListBox = new KrListWidget(profileHandler);
profileLayout->addWidget(profileListBox, 0, 0, 4, 1);
profileAddBtn = new QPushButton(profileHandler);
KStandardGuiItem::assign(profileAddBtn, KStandardGuiItem::Add);
profileLayout->addWidget(profileAddBtn, 0, 1);
profileLoadBtn = new QPushButton(i18n("&Load"), profileHandler);
profileLoadBtn->setEnabled(false);
profileLayout->addWidget(profileLoadBtn, 1, 1);
profileOverwriteBtn = new QPushButton(profileHandler);
profileOverwriteBtn->setEnabled(false);
KStandardGuiItem::assign(profileOverwriteBtn, KStandardGuiItem::Overwrite);
profileLayout->addWidget(profileOverwriteBtn, 2, 1);
profileRemoveBtn = new QPushButton(profileHandler);
profileRemoveBtn->setEnabled(false);
KStandardGuiItem::assign(profileRemoveBtn, KStandardGuiItem::Remove);
profileLayout->addWidget(profileRemoveBtn, 3, 1);
profileManager = new ProfileManager("SelectionProfile", this);
profileManager->hide();
middleLayout->addWidget(profileHandler);
refreshProfileListBox();
}
if (properties & FilterTabs::HasSearchIn) {
// Options for search in
QGroupBox *searchGroupBox = new QGroupBox(i18n("Searc&h in"), this);
auto *searchLayout = new QGridLayout(searchGroupBox);
searchLayout->setAlignment(Qt::AlignTop);
searchLayout->setSpacing(6);
searchLayout->setContentsMargins(11, 11, 11, 11);
searchIn = new KURLListRequester(KURLListRequester::RequestDirs, searchGroupBox);
searchLayout->addWidget(searchIn, 0, 0);
connect(searchIn, &KURLListRequester::changed, this, &GeneralFilter::slotDisable);
middleLayout->addWidget(searchGroupBox);
}
if (properties & FilterTabs::HasDontSearchIn) {
// Options for don't search in
QGroupBox *searchGroupBox = new QGroupBox(i18n("&Do not search in"), this);
auto *searchLayout = new QGridLayout(searchGroupBox);
searchLayout->setAlignment(Qt::AlignTop);
searchLayout->setSpacing(6);
searchLayout->setContentsMargins(11, 11, 11, 11);
dontSearchIn = new KURLListRequester(KURLListRequester::RequestDirs, searchGroupBox);
searchLayout->addWidget(dontSearchIn, 0, 0, 1, 2);
if (properties & FilterTabs::HasRecurseOptions) {
KConfigGroup group(krConfig, "Search");
useExcludeFolderNames = createExcludeCheckBox(group);
searchLayout->addWidget(useExcludeFolderNames, 1, 0, 1, 1);
excludeFolderNames = createExcludeComboBox(group);
searchLayout->addWidget(excludeFolderNames, 1, 1, 1, 1);
if (!useExcludeFolderNames->isChecked()) {
excludeFolderNames->setDisabled(true);
}
connect(useExcludeFolderNames, &QCheckBox::toggled, excludeFolderNames, &KHistoryComboBox::setEnabled);
}
middleLayout->addWidget(searchGroupBox);
}
filterLayout->addLayout(middleLayout, 1, 0);
// Options for containing text
auto *containsGroup = new QGroupBox(this);
containsGroup->setTitle(i18n("Containing text"));
auto *containsLayout = new QGridLayout(containsGroup);
containsLayout->setAlignment(Qt::AlignTop);
containsLayout->setSpacing(6);
containsLayout->setContentsMargins(11, 11, 11, 11);
auto *containsTextLayout = new QHBoxLayout();
containsTextLayout->setSpacing(6);
containsTextLayout->setContentsMargins(0, 0, 0, 0);
containsLabel = new QLabel(containsGroup);
QSizePolicy containsLabelPolicy(QSizePolicy::Fixed, QSizePolicy::Minimum);
containsLabelPolicy.setHeightForWidth(containsLabel->sizePolicy().hasHeightForWidth());
containsLabel->setSizePolicy(containsLabelPolicy);
containsLabel->setText(i18n("&Text:"));
containsTextLayout->addWidget(containsLabel);
containsText = new KHistoryComboBox(false, containsGroup/*, "containsText"*/);
QSizePolicy containsTextPolicy(QSizePolicy::Expanding, QSizePolicy::Fixed);
containsTextPolicy.setHeightForWidth(containsText->sizePolicy().hasHeightForWidth());
containsText->setSizePolicy(containsTextPolicy);
containsText->setDuplicatesEnabled(false);
containsText->setMaxCount(25);
containsText->setMinimumContentsLength(10);
containsTextLayout->addWidget(containsText);
containsLabel->setBuddy(containsText);
containsRegExp = new QToolButton(containsGroup);
containsRegExp->setPopupMode(QToolButton::MenuButtonPopup);
containsRegExp->setCheckable(true);
containsRegExp->setText(i18n("RegExp"));
// Populate the popup menu.
auto *patterns = new QMenu(containsRegExp);
for (int i = 0; (unsigned)i < sizeof(items) / sizeof(items[0]); i++) {
patterns->addAction(new RegExpAction(patterns, i18n(items[i].description),
items[i].regExp, items[i].cursorAdjustment));
}
connect(containsRegExp, &QToolButton::toggled, this, &GeneralFilter::slotDisable);
connect(containsRegExp, &QToolButton::triggered, this, &GeneralFilter::slotRegExpTriggered);
containsRegExp->setMenu(patterns);
patterns->setEnabled(false);
containsTextLayout->addWidget(containsRegExp);
containsLayout->addLayout(containsTextLayout, 0, 0);
auto *containsCbsLayout = new QHBoxLayout();
containsCbsLayout->setSpacing(6);
containsCbsLayout->setContentsMargins(0, 0, 0, 0);
encLabel = new QLabel(i18n("Encoding:"), containsGroup);
containsCbsLayout->addWidget(encLabel);
contentEncoding = new KComboBox(containsGroup);
contentEncoding->setEditable(false);
contentEncoding->addItem(i18nc("Default encoding", "Default"));
contentEncoding->addItems(KCharsets::charsets()->descriptiveEncodingNames());
containsCbsLayout->addWidget(contentEncoding);
auto* cbSpacer = new QSpacerItem(20, 20, QSizePolicy::Expanding, QSizePolicy::Minimum);
containsCbsLayout->addItem(cbSpacer);
containsWholeWord = new QCheckBox(containsGroup);
QSizePolicy containsWholeWordPolicy(QSizePolicy::Preferred, QSizePolicy::Fixed);
containsWholeWordPolicy.setHeightForWidth(containsWholeWord->sizePolicy().hasHeightForWidth());
containsWholeWord->setSizePolicy(containsWholeWordPolicy);
containsWholeWord->setText(i18n("&Match whole word only"));
containsWholeWord->setChecked(false);
containsCbsLayout->addWidget(containsWholeWord);
containsTextCase = new QCheckBox(containsGroup);
QSizePolicy containsTextCasePolicy(QSizePolicy::Preferred, QSizePolicy::Fixed);
containsTextCasePolicy.setHeightForWidth(containsTextCase->sizePolicy().hasHeightForWidth());
containsTextCase->setSizePolicy(containsTextCasePolicy);
containsTextCase->setText(i18n("Cas&e sensitive"));
containsTextCase->setChecked(true);
containsCbsLayout->addWidget(containsTextCase);
containsLayout->addLayout(containsCbsLayout, 1, 0);
filterLayout->addWidget(containsGroup, 2, 0);
auto *recurseLayout = new QHBoxLayout();
recurseLayout->setSpacing(6);
recurseLayout->setContentsMargins(0, 0, 0, 0);
auto* recurseSpacer = new QSpacerItem(20, 20, QSizePolicy::Expanding, QSizePolicy::Minimum);
recurseLayout->addItem(recurseSpacer);
if (properties & FilterTabs::HasRecurseOptions) {
// Options for recursive searching
searchInDirs = new QCheckBox(this);
searchInDirs->setText(i18n("Search in s&ub folders"));
searchInDirs->setChecked(true);
recurseLayout->addWidget(searchInDirs);
searchInArchives = new QCheckBox(this);
searchInArchives->setText(i18n("Search in arch&ives"));
recurseLayout->addWidget(searchInArchives);
followLinks = new QCheckBox(this);
followLinks->setText(i18n("Follow &links"));
recurseLayout->addWidget(followLinks);
}
filterLayout->addLayout(recurseLayout, 3, 0);
for(int i = 0; i < extraOptions.length(); i++) {
auto *option = new QCheckBox(this);
option->setText(extraOptions[i]);
recurseLayout->addWidget(option);
this->extraOptions.insert(extraOptions[i], option);
}
// Connection table
if (properties & FilterTabs::HasProfileHandler) {
connect(profileAddBtn, &QPushButton::clicked, this, &GeneralFilter::slotAddBtnClicked);
connect(profileLoadBtn, &QPushButton::clicked, this, &GeneralFilter::slotLoadBtnClicked);
connect(profileOverwriteBtn, &QPushButton::clicked, this, &GeneralFilter::slotOverwriteBtnClicked);
connect(profileRemoveBtn, &QPushButton::clicked, this, &GeneralFilter::slotRemoveBtnClicked);
connect(profileListBox, &KrListWidget::itemDoubleClicked, this, &GeneralFilter::slotProfileDoubleClicked);
connect(profileManager, &ProfileManager::loadFromProfile, fltTabs, &FilterTabs::loadFromProfile);
connect(profileManager, &ProfileManager::saveToProfile, fltTabs, &FilterTabs::saveToProfile);
}
connect(searchFor, QOverload::of(&KHistoryComboBox::activated), searchFor, &KHistoryComboBox::addToHistory);
connect(containsText, QOverload::of(&KHistoryComboBox::activated), containsText, &KHistoryComboBox::addToHistory);
// load the completion and history lists
// ==> search for
KConfigGroup group(krConfig, "Search");
QStringList list = group.readEntry("SearchFor Completion", QStringList());
searchFor->completionObject()->setItems(list);
list = group.readEntry("SearchFor History", QStringList());
searchFor->setHistoryItems(list);
// ==> grep
list = group.readEntry("ContainsText Completion", QStringList());
containsText->completionObject()->setItems(list);
list = group.readEntry("ContainsText History", QStringList());
containsText->setHistoryItems(list);
setTabOrder(searchFor, containsText); // search for -> content
setTabOrder(containsText, searchType); // content -> search type
slotDisable();
}
GeneralFilter::~GeneralFilter()
{
// save the history combos
// ==> search for
QStringList list = searchFor->completionObject()->items();
KConfigGroup group(krConfig, "Search");
group.writeEntry("SearchFor Completion", list);
list = searchFor->historyItems();
group.writeEntry("SearchFor History", list);
// ==> grep text
list = containsText->completionObject()->items();
group.writeEntry("ContainsText Completion", list);
list = containsText->historyItems();
group.writeEntry("ContainsText History", list);
if ((properties & FilterTabs::HasDontSearchIn) && (properties & FilterTabs::HasRecurseOptions)) {
list = excludeFolderNames->historyItems();
group.writeEntry("ExcludeFolderNamesHistory", list);
group.writeEntry("ExcludeFolderNames", excludeFolderNames->currentText());
group.writeEntry("ExcludeFolderNamesUse", static_cast(useExcludeFolderNames->checkState()));
}
krConfig->sync();
}
bool GeneralFilter::isExtraOptionChecked(const QString& name)
{
QCheckBox *option = extraOptions[name];
return option ? option->isChecked() : false;
}
void GeneralFilter::checkExtraOption(const QString& name, bool check)
{
QCheckBox *option = extraOptions[name];
if (option)
option->setChecked(check);
}
void GeneralFilter::queryAccepted()
{
searchFor->addToHistory(searchFor->currentText());
containsText->addToHistory(containsText->currentText());
if ((properties & FilterTabs::HasDontSearchIn) && (properties & FilterTabs::HasRecurseOptions)) {
excludeFolderNames->addToHistory(excludeFolderNames->currentText());
}
}
void GeneralFilter::refreshProfileListBox()
{
profileListBox->clear();
profileListBox->addItems(ProfileManager::availableProfiles("SelectionProfile"));
if (profileListBox->count() != 0) {
profileLoadBtn->setEnabled(true);
profileOverwriteBtn->setEnabled(true);
profileRemoveBtn->setEnabled(true);
} else {
profileLoadBtn->setEnabled(false);
profileOverwriteBtn->setEnabled(false);
profileRemoveBtn->setEnabled(false);
}
}
QCheckBox *GeneralFilter::createExcludeCheckBox(const KConfigGroup &group)
{
auto *excludeCheckBox = new QCheckBox(this);
excludeCheckBox->setText(i18n("Exclude Folder Names"));
- excludeCheckBox->setToolTip(i18n("Filters out specified directory names from the results."));
+ excludeCheckBox->setToolTip(i18n("Filters out specified folder names from the results."));
excludeCheckBox->setChecked(static_cast(group.readEntry("ExcludeFolderNamesUse", 0)));
return excludeCheckBox;
}
KHistoryComboBox *GeneralFilter::createExcludeComboBox(const KConfigGroup &group)
{
auto *excludeComboBox = new KHistoryComboBox(false, this);
QSizePolicy excludeFolderNamesPolicy(QSizePolicy::Expanding, QSizePolicy::Fixed);
excludeFolderNamesPolicy.setHeightForWidth(excludeComboBox->sizePolicy().hasHeightForWidth());
excludeComboBox->setSizePolicy(excludeFolderNamesPolicy);
excludeComboBox->setEditable(true);
excludeComboBox->setDuplicatesEnabled(false);
excludeComboBox->setMaxCount(25);
excludeComboBox->setMinimumContentsLength(10);
excludeComboBox->lineEdit()->setPlaceholderText(i18n("Enter space-separated folder names"));
excludeComboBox->lineEdit()->setWhatsThis(
i18n("You can insert names with escaped spaces or quoted.\nExample: .git \"target "
"build\" build\\ krusader"));
excludeComboBox->setHistoryItems(group.readEntry("ExcludeFolderNamesHistory", QStringList()));
excludeComboBox->setEditText(group.readEntry("ExcludeFolderNames", ""));
return excludeComboBox;
}
void GeneralFilter::slotAddBtnClicked()
{
profileManager->newProfile(searchFor->currentText().simplified());
refreshProfileListBox();
}
void GeneralFilter::slotOverwriteBtnClicked()
{
QListWidgetItem *item = profileListBox->currentItem();
if (item != nullptr)
profileManager->overwriteProfile(item->text());
}
void GeneralFilter::slotRemoveBtnClicked()
{
QListWidgetItem *item = profileListBox->currentItem();
if (item != nullptr) {
profileManager->deleteProfile(item->text());
refreshProfileListBox();
}
}
void GeneralFilter::slotProfileDoubleClicked(QListWidgetItem *item)
{
if (item != nullptr) {
QString profileName = item->text();
profileManager->loadProfile(profileName);
fltTabs->close(true);
}
}
void GeneralFilter::slotLoadBtnClicked()
{
QListWidgetItem *item = profileListBox->currentItem();
if (item != nullptr)
profileManager->loadProfile(item->text());
}
void GeneralFilter::slotDisable()
{
bool state = containsRegExp->isChecked();
bool global = ofType->currentText() != i18n("Folders");
bool remoteOnly = false;
if (properties & FilterTabs::HasSearchIn) {
QList urlList = searchIn->urlList();
remoteOnly = urlList.count() != 0;
foreach(const QUrl &url, urlList)
if (url.scheme() == "file")
remoteOnly = false;
}
containsWholeWord->setEnabled(!state && global);
containsRegExp->menu()->setEnabled(state && global);
encLabel->setEnabled(global);
contentEncoding->setEnabled(global);
containsTextCase->setEnabled(global);
containsRegExp->setEnabled(global);
if (properties & FilterTabs::HasRecurseOptions)
searchInArchives->setEnabled(global && !remoteOnly);
containsLabel->setEnabled(global);
containsText->setEnabled(global);
}
void GeneralFilter::slotRegExpTriggered(QAction * act)
{
if (act == nullptr)
return;
auto *regAct = dynamic_cast(act);
if (regAct == nullptr)
return;
containsText->lineEdit()->insert(regAct->regExp());
containsText->lineEdit()->setCursorPosition(containsText->lineEdit()->cursorPosition() + regAct->cursor());
containsText->lineEdit()->setFocus();
}
bool GeneralFilter::getSettings(FilterSettings &s)
{
// check that we have (at least) what to search, and where to search in
if (searchFor->currentText().simplified().isEmpty()) {
KMessageBox::error(this , i18n("No search criteria entered."));
searchFor->setFocus();
return false;
}
s.searchFor = searchFor->currentText().trimmed();
s.searchForCase = searchForCase->isChecked();
if (ofType->currentText() != i18n("All Files"))
s.mimeType = ofType->currentText();
if (containsText->isEnabled()) {
s.containsText = containsText->currentText();
s.containsTextCase = containsTextCase->isChecked();
s.containsWholeWord = containsWholeWord->isChecked();
s.containsRegExp = containsRegExp->isChecked();
}
if (contentEncoding->currentIndex() != 0)
s.contentEncoding =
KCharsets::charsets()->encodingForName(contentEncoding->currentText());
if (properties & FilterTabs::HasRecurseOptions) {
s.recursive = searchInDirs->isChecked();
s.searchInArchives = searchInArchives->isChecked();
s.followLinks = followLinks->isChecked();
}
if (properties & FilterTabs::HasSearchIn) {
s.searchIn = searchIn->urlList();
if (s.searchIn.isEmpty()) { // we need a place to search in
KMessageBox::error(this , i18n("Please specify a location to search in."));
searchIn->lineEdit()->setFocus();
return false;
}
}
if (properties & FilterTabs::HasDontSearchIn) {
s.dontSearchIn = dontSearchIn->urlList();
if (properties & FilterTabs::HasRecurseOptions) {
if (useExcludeFolderNames->isChecked()) {
s.excludeFolderNames = KShell::splitArgs(excludeFolderNames->currentText());
} else {
s.excludeFolderNames = QStringList();
}
}
}
return true;
}
void GeneralFilter::applySettings(const FilterSettings &s)
{
searchFor->setEditText(s.searchFor);
searchForCase->setChecked(s.searchForCase);
setComboBoxValue(ofType, s.mimeType);
containsText->setEditText(s.containsText);
containsTextCase->setChecked(s.containsTextCase);
containsWholeWord->setChecked(s.containsWholeWord);
containsRegExp->setChecked(s.containsRegExp);
setComboBoxValue(contentEncoding,
KCharsets::charsets()->descriptionForEncoding(s.contentEncoding));
if (properties & FilterTabs::HasRecurseOptions) {
searchInDirs->setChecked(s.recursive);
searchInArchives->setChecked(s.searchInArchives);
followLinks->setChecked(s.followLinks);
}
if (properties & FilterTabs::HasSearchIn) {
searchIn->lineEdit()->clear();
searchIn->listBox()->clear();
searchIn->listBox()->addItems(KrServices::toStringList(s.searchIn));
}
if (properties & FilterTabs::HasDontSearchIn) {
dontSearchIn->lineEdit()->clear();
dontSearchIn->listBox()->clear();
dontSearchIn->listBox()->addItems(KrServices::toStringList(s.dontSearchIn));
}
}
diff --git a/krusader/Konfigurator/kgpanel.cpp b/krusader/Konfigurator/kgpanel.cpp
index a5738dcf..12d90382 100644
--- a/krusader/Konfigurator/kgpanel.cpp
+++ b/krusader/Konfigurator/kgpanel.cpp
@@ -1,745 +1,745 @@
/*****************************************************************************
* Copyright (C) 2010 Jan Lepper *
* Copyright (C) 2010-2019 Krusader Krew [https://krusader.org] *
* *
* This file is part of Krusader [https://krusader.org]. *
* *
* Krusader 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. *
* *
* Krusader 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 Krusader. If not, see [http://www.gnu.org/licenses/]. *
*****************************************************************************/
#include "kgpanel.h"
#include "../defaults.h"
#include "../Dialogs/krdialogs.h"
// QtGui
#include
// QtWidgets
#include
#include
#include
#include
#include
#include
#include
#include "../GUI/krtreewidget.h"
#include "../Panel/krsearchbar.h"
#include "../Panel/PanelView/krselectionmode.h"
#include "../Panel/PanelView/krview.h"
#include "../Panel/PanelView/krviewfactory.h"
#include "../Panel/krlayoutfactory.h"
enum {
PAGE_GENERAL = 0,
PAGE_VIEW,
PAGE_PANELTOOLBAR,
PAGE_MOUSE,
PAGE_MEDIA_MENU,
PAGE_LAYOUT
};
KgPanel::KgPanel(bool first, QWidget* parent) :
KonfiguratorPage(first, parent)
{
tabWidget = new QTabWidget(this);
setWidget(tabWidget);
setWidgetResizable(true);
setupGeneralTab();
setupPanelTab();
setupButtonsTab();
setupMouseModeTab();
setupMediaMenuTab();
setupLayoutTab();
}
// ---------------------------------------------------------------------------------------
// ---------------------------- General TAB ----------------------------------------------
// ---------------------------------------------------------------------------------------
void KgPanel::setupGeneralTab()
{
auto *scrollArea = new QScrollArea(tabWidget);
QWidget *tab = new QWidget(scrollArea);
scrollArea->setFrameStyle(QFrame::NoFrame);
scrollArea->setWidget(tab);
scrollArea->setWidgetResizable(true);
tabWidget->addTab(scrollArea, i18n("General"));
auto *layout = new QVBoxLayout(tab);
layout->setSpacing(6);
layout->setContentsMargins(11, 11, 11, 11);
// ---------------------------------------------------------------------------------------
// ------------------------------- Navigator bar -------------------------------------
// ---------------------------------------------------------------------------------------
QGroupBox *groupBox = createFrame(i18n("Navigator bar"), tab);
QGridLayout *gridLayout = createGridLayout(groupBox);
KONFIGURATOR_CHECKBOX_PARAM navigatorbar_settings[] = {
// cfg_class, cfg_name, default, text, restart, tooltip
{"Look&Feel", "Navigator Edit Mode", false, i18n("Edit Mode by default"), true, i18n("Show editable path in Navigator bar by default") },
{"Look&Feel", "Navigator Full Path", false, i18n("Show full path by default"), true, i18n("Always show full path in Navigator bar by default.") },
};
KonfiguratorCheckBoxGroup* cbs = createCheckBoxGroup(2, 0, navigatorbar_settings, 2 /*count*/, groupBox, PAGE_GENERAL);
gridLayout->addWidget(cbs, 0, 0);
layout->addWidget(groupBox);
// ---------------------------------------------------------------------------------------
// ------------------------------- Operation ---------------------------------------------
// ---------------------------------------------------------------------------------------
groupBox = createFrame(i18n("Operation"), tab);
gridLayout = createGridLayout(groupBox);
KONFIGURATOR_CHECKBOX_PARAM operation_settings[] = { // cfg_class, cfg_name, default, text, restart, tooltip
{"Look&Feel", "Mark Dirs", _MarkDirs, i18n("Autoselect folders"), false, i18n("When matching the select criteria, not only files will be selected, but also folders.") },
{"Look&Feel", "Rename Selects Extension", true, i18n("Rename selects extension"), false, i18n("When renaming a file, the whole text is selected. If you want Total-Commander like renaming of just the name, without extension, uncheck this option.") },
{"Look&Feel", "UnselectBeforeOperation", _UnselectBeforeOperation, i18n("Unselect files before copy/move"), false, i18n("Unselect files, which are to be copied/moved, before the operation starts.") },
{"Look&Feel", "FilterDialogRemembersSettings", _FilterDialogRemembersSettings, i18n("Filter dialog remembers settings"), false, i18n("The filter dialog is opened with the last filter settings that where applied to the panel.") },
};
cbs = createCheckBoxGroup(2, 0, operation_settings, 4 /*count*/, groupBox, PAGE_GENERAL);
gridLayout->addWidget(cbs, 0, 0);
layout->addWidget(groupBox);
// ---------------------------------------------------------------------------------------
// ------------------------------ Tabs ---------------------------------------------------
// ---------------------------------------------------------------------------------------
groupBox = createFrame(i18n("Tabs"), tab);
gridLayout = createGridLayout(groupBox);
KONFIGURATOR_CHECKBOX_PARAM tabbar_settings[] = { // cfg_class cfg_name default text restart tooltip
{"Look&Feel", "Fullpath Tab Names", _FullPathTabNames, i18n("Use full path tab names"), true , i18n("Display the full path in the folder tabs. By default only the last part of the path is displayed.") },
{"Look&Feel", "Show Tab Buttons", true, i18n("Show new/close tab buttons"), true , i18n("Show the new/close tab buttons.") },
};
cbs = createCheckBoxGroup(2, 0, tabbar_settings, 2 /*count*/, groupBox, PAGE_GENERAL);
gridLayout->addWidget(cbs, 0, 0, 1, 2);
// ----------------- Tab Bar position ----------------------------------
auto *hbox = new QHBoxLayout();
hbox->addWidget(new QLabel(i18n("Tab Bar position:"), groupBox));
KONFIGURATOR_NAME_VALUE_PAIR positions[] = {
{ i18n("Top"), "top" },
{ i18n("Bottom"), "bottom" }
};
KonfiguratorComboBox *cmb = createComboBox("Look&Feel", "Tab Bar Position",
"bottom", positions, 2, groupBox, true, false, PAGE_GENERAL);
hbox->addWidget(cmb);
gridLayout->addLayout(hbox, 1, 0, Qt::AlignLeft);
// ----------------- Show Tab bar ----------------------------------
KonfiguratorCheckBox *checkBox = createCheckBox("Look&Feel", "Show Tab Bar On Single Tab", true,
i18n("Show Tab Bar on single tab"), groupBox,
true, i18n("Show the tab bar with only one tab."));
gridLayout->addWidget(checkBox, 1, 1, Qt::AlignLeft);
layout->addWidget(groupBox);
// ---------------------------------------------------------------------------------------
// ----------------------------- Search bar --------------------------------------------
// ---------------------------------------------------------------------------------------
groupBox = createFrame(i18n("Search bar"), tab);
gridLayout = createGridLayout(groupBox);
KONFIGURATOR_CHECKBOX_PARAM quicksearch[] = { // cfg_class cfg_name default text restart tooltip
{"Look&Feel", "New Style Quicksearch", _NewStyleQuicksearch, i18n("Start by typing"), false, i18n("Open search bar and start searching by typing in panel.") },
{"Look&Feel", "Case Sensitive Quicksearch", _CaseSensitiveQuicksearch, i18n("Case sensitive"), false, i18n("Search must match case.") },
{"Look&Feel", "Up/Down Cancels Quicksearch", false, i18n("Up/Down cancels search"), false, i18n("Pressing the Up/Down buttons closes the search bar (only in search mode).") },
- {"Look&Feel", "Navigation with Right Arrow Quicksearch", _NavigationWithRightArrowQuicksearch, i18n("Directory navigation with Right Arrow"), false, i18n("Pressing the Right button enters directory if no search text editing intention is captured.") },
+ {"Look&Feel", "Navigation with Right Arrow Quicksearch", _NavigationWithRightArrowQuicksearch, i18n("Folder navigation with Right Arrow"), false, i18n("Pressing the Right button enters folder if no search text editing intention is captured.") },
};
cbs = createCheckBoxGroup(2, 0, quicksearch, 4 /*count*/, groupBox, PAGE_GENERAL);
gridLayout->addWidget(cbs, 0, 0, 1, -1);
// -------------- Search bar position -----------------------
hbox = new QHBoxLayout();
hbox->addWidget(new QLabel(i18n("Position:"), groupBox));
cmb = createComboBox("Look&Feel", "Quicksearch Position",
"bottom", positions, 2, groupBox, true, false, PAGE_GENERAL);
hbox->addWidget(cmb);
hbox->addWidget(createSpacer(groupBox));
gridLayout->addLayout(hbox, 1, 0);
// -------------- Default search mode -----------------------
hbox = new QHBoxLayout();
hbox->addWidget(new QLabel(i18n("Default mode:"), groupBox));
KONFIGURATOR_NAME_VALUE_PAIR modes[] = {
{i18n("Search"), QString::number(KrSearchBar::MODE_SEARCH)},
{i18n("Select"), QString::number(KrSearchBar::MODE_SELECT)},
{i18n("Filter"), QString::number(KrSearchBar::MODE_FILTER)}};
cmb = createComboBox("Look&Feel", "Default Search Mode",
QString::number(KrSearchBar::MODE_SEARCH), modes, 3, groupBox, true, false,
PAGE_GENERAL);
cmb->setToolTip(i18n("Set the default mode on first usage"));
hbox->addWidget(cmb);
hbox->addWidget(createSpacer(groupBox));
gridLayout->addLayout(hbox, 1, 1);
layout->addWidget(groupBox);
// --------------------------------------------------------------------------------------------
// ------------------------------- Bookmark search settings ----------------------------------
// --------------------------------------------------------------------------------------------
groupBox = createFrame(i18n("Bookmark Search"), tab);
gridLayout = createGridLayout(groupBox);
KONFIGURATOR_CHECKBOX_PARAM bookmarkSearchSettings[] =
{
{"Look&Feel", "Always show search bar", true, i18n("Always show search bar"), false, i18n("Make bookmark search bar always visible") },
{"Look&Feel", "Search in special items", false, i18n("Search in special items"), false, i18n("Bookmark search is also applied to special items in bookmark menu like Trash, Popular URLs, Jump Back, etc.") },
};
KonfiguratorCheckBoxGroup *bookmarkSearchSettingsGroup = createCheckBoxGroup(2, 0, bookmarkSearchSettings,
2 /*count*/, groupBox, PAGE_GENERAL);
gridLayout->addWidget(bookmarkSearchSettingsGroup, 1, 0, 1, 2);
layout->addWidget(groupBox);
// --------------------------------------------------------------------------------------------
// ------------------------------- Status/Totalsbar settings ----------------------------------
// --------------------------------------------------------------------------------------------
groupBox = createFrame(i18n("Status/Totalsbar"), tab);
gridLayout = createGridLayout(groupBox);
KONFIGURATOR_CHECKBOX_PARAM barSettings[] =
{
{"Look&Feel", "Show Size In Bytes", false, i18n("Show size in bytes too"), true, i18n("Show size in bytes too") },
{"Look&Feel", "ShowSpaceInformation", true, i18n("Show space information"), true, i18n("Show free/total space on the device") },
};
KonfiguratorCheckBoxGroup *barSett = createCheckBoxGroup(2, 0, barSettings,
2 /*count*/, groupBox, PAGE_GENERAL);
gridLayout->addWidget(barSett, 1, 0, 1, 2);
layout->addWidget(groupBox);
}
// --------------------------------------------------------------------------------------------
// ------------------------------------ Layout Tab --------------------------------------------
// --------------------------------------------------------------------------------------------
void KgPanel::setupLayoutTab()
{
auto *scrollArea = new QScrollArea(tabWidget);
QWidget *tab = new QWidget(scrollArea);
scrollArea->setFrameStyle(QFrame::NoFrame);
scrollArea->setWidget(tab);
scrollArea->setWidgetResizable(true);
tabWidget->addTab(scrollArea, i18n("Layout"));
QGridLayout *grid = createGridLayout(tab);
QStringList layoutNames = KrLayoutFactory::layoutNames();
int numLayouts = layoutNames.count();
grid->addWidget(createSpacer(tab), 0, 2);
QLabel *l = new QLabel(i18n("Layout:"), tab);
l->setAlignment(Qt::AlignRight | Qt::AlignVCenter);
grid->addWidget(l, 0, 0);
auto *layouts = new KONFIGURATOR_NAME_VALUE_PAIR[numLayouts];
for (int i = 0; i != numLayouts; i++) {
layouts[ i ].text = KrLayoutFactory::layoutDescription(layoutNames[i]);
layouts[ i ].value = layoutNames[i];
}
KonfiguratorComboBox *cmb = createComboBox("PanelLayout", "Layout", "default",
layouts, numLayouts, tab, true, false, PAGE_LAYOUT);
grid->addWidget(cmb, 0, 1);
delete [] layouts;
l = new QLabel(i18n("Frame Color:"), tab);
l->setAlignment(Qt::AlignRight | Qt::AlignVCenter);
grid->addWidget(l, 1, 0);
KONFIGURATOR_NAME_VALUE_PAIR frameColor[] = {
{ i18nc("Frame color", "Defined by Layout"), "default" },
{ i18nc("Frame color", "None"), "none" },
{ i18nc("Frame color", "Statusbar"), "Statusbar" }
};
cmb = createComboBox("PanelLayout", "FrameColor",
"default", frameColor, 3, tab, true, false, PAGE_LAYOUT);
grid->addWidget(cmb, 1, 1);
l = new QLabel(i18n("Frame Shape:"), tab);
l->setAlignment(Qt::AlignRight | Qt::AlignVCenter);
grid->addWidget(l, 2, 0);
KONFIGURATOR_NAME_VALUE_PAIR frameShape[] = {
{ i18nc("Frame shape", "Defined by Layout"), "default" },
{ i18nc("Frame shape", "None"), "NoFrame" },
{ i18nc("Frame shape", "Box"), "Box" },
{ i18nc("Frame shape", "Panel"), "Panel" },
};
cmb = createComboBox("PanelLayout", "FrameShape",
"default", frameShape, 4, tab, true, false, PAGE_LAYOUT);
grid->addWidget(cmb, 2, 1);
l = new QLabel(i18n("Frame Shadow:"), tab);
l->setAlignment(Qt::AlignRight | Qt::AlignVCenter);
grid->addWidget(l, 3, 0);
KONFIGURATOR_NAME_VALUE_PAIR frameShadow[] = {
{ i18nc("Frame shadow", "Defined by Layout"), "default" },
{ i18nc("Frame shadow", "None"), "Plain" },
{ i18nc("Frame shadow", "Raised"), "Raised" },
{ i18nc("Frame shadow", "Sunken"), "Sunken" },
};
cmb = createComboBox("PanelLayout", "FrameShadow",
"default", frameShadow, 4, tab, true, false, PAGE_LAYOUT);
grid->addWidget(cmb, 3, 1);
}
void KgPanel::setupView(KrViewInstance *instance, QWidget *parent)
{
QGridLayout *grid = createGridLayout(parent);
// -------------------- Filelist icon size ----------------------------------
auto *hbox = new QHBoxLayout();
hbox->addWidget(new QLabel(i18n("Default icon size:"), parent));
auto *iconSizes = new KONFIGURATOR_NAME_VALUE_PAIR[KrView::iconSizes.count()];
for(int i = 0; i < KrView::iconSizes.count(); i++)
iconSizes[i].text = iconSizes[i].value = QString::number(KrView::iconSizes[i]);
KonfiguratorComboBox *cmb = createComboBox(instance->name(), "IconSize", _FilelistIconSize, iconSizes, KrView::iconSizes.count(), parent, true, true, PAGE_VIEW);
delete [] iconSizes;
cmb->lineEdit()->setValidator(new QRegExpValidator(QRegExp("[1-9]\\d{0,1}"), cmb));
hbox->addWidget(cmb);
hbox->addWidget(createSpacer(parent));
grid->addLayout(hbox, 1, 0);
//--------------------------------------------------------------------
KONFIGURATOR_CHECKBOX_PARAM iconSettings[] =
// cfg_class cfg_name default text restart tooltip
{
{instance->name(), "With Icons", _WithIcons, i18n("Use icons in the filenames"), true, i18n("Show the icons for filenames and folders.") },
{instance->name(), "ShowPreviews", false, i18n("Show previews by default"), false, i18n("Show previews of files and folders.") },
};
KonfiguratorCheckBoxGroup *iconSett = createCheckBoxGroup(2, 0, iconSettings, 2 /*count*/, parent, PAGE_VIEW);
grid->addWidget(iconSett, 2, 0, 1, 2);
}
// ----------------------------------------------------------------------------------
// ---------------------------- VIEW TAB -------------------------------------------
// ----------------------------------------------------------------------------------
void KgPanel::setupPanelTab()
{
auto *scrollArea = new QScrollArea(tabWidget);
QWidget *tab_panel = new QWidget(scrollArea);
scrollArea->setFrameStyle(QFrame::NoFrame);
scrollArea->setWidget(tab_panel);
scrollArea->setWidgetResizable(true);
tabWidget->addTab(scrollArea, i18n("View"));
auto *panelLayout = new QGridLayout(tab_panel);
panelLayout->setSpacing(6);
panelLayout->setContentsMargins(11, 11, 11, 11);
QGroupBox *panelGrp = createFrame(i18n("General"), tab_panel);
panelLayout->addWidget(panelGrp, 0, 0);
QGridLayout *panelGrid = createGridLayout(panelGrp);
// ----------------------------------------------------------------------------------
// ---------------------------- General settings -----------------------------------
// ----------------------------------------------------------------------------------
// -------------------- Panel Font ----------------------------------
auto *hbox = new QHBoxLayout();
auto *fontLayout = new QHBoxLayout();
fontLayout->addWidget(new QLabel(i18n("View font:"), panelGrp));
KonfiguratorFontChooser *chsr =
createFontChooser("Look&Feel", "Filelist Font", _FilelistFont, panelGrp, true, PAGE_VIEW);
fontLayout->addWidget(chsr);
fontLayout->addStretch(1);
hbox->addLayout(fontLayout, 1);
// -------------------- Panel Tooltip ----------------------------------
auto *tooltipLayout = new QHBoxLayout();
QLabel *tooltipLabel = new QLabel(i18n("Tooltip delay (msec):"));
tooltipLabel->setWhatsThis(i18n("The duration after a tooltip is shown for a file item, in "
"milliseconds. Set a negative value to disable tooltips."));
tooltipLayout->addWidget(tooltipLabel);
KonfiguratorSpinBox *tooltipSpinBox = createSpinBox("Look&Feel", "Panel Tooltip Delay", 1000,
-100, 5000, panelGrp, false, PAGE_VIEW);
tooltipSpinBox->setSingleStep(100);
tooltipLayout->addWidget(tooltipSpinBox);
tooltipLayout->addStretch(1);
hbox->addLayout(tooltipLayout, 1);
panelGrid->addLayout(hbox, 1, 0);
// -------------------- General options ----------------------------------
KONFIGURATOR_CHECKBOX_PARAM panelSettings[] =
// cfg_class cfg_name default text restart tooltip
{
{"Look&Feel", "Human Readable Size", _HumanReadableSize, i18n("Use human-readable file size"), true , i18n("File sizes are displayed in B, KB, MB and GB, not just in bytes.") },
{"Look&Feel", "Show Hidden", _ShowHidden, i18n("Show hidden files"), false, i18n("Display files beginning with a dot.") },
{"Look&Feel", "Numeric permissions", _NumericPermissions, i18n("Numeric Permissions"), true, i18n("Show octal numbers (0755) instead of the standard permissions (rwxr-xr-x) in the permission column.") },
{"Look&Feel", "Load User Defined Folder Icons", _UserDefinedFolderIcons, i18n("Load the user defined folder icons"), true , i18n("Load the user defined folder icons (can cause decrease in performance).") },
{"Look&Feel", "Always Show Current Item", _AlwaysShowCurrentItem, i18n("Always show current item"), false, i18n("Show current item border decoration in inactive panel.") },
};
KonfiguratorCheckBoxGroup *panelSett = createCheckBoxGroup(2, 0, panelSettings, 5 /*count*/, panelGrp, PAGE_VIEW);
panelGrid->addWidget(panelSett, 3, 0, 1, 2);
// =========================================================
panelGrid->addWidget(createLine(panelGrp), 4, 0);
// ------------------------ Sort Method ----------------------------------
hbox = new QHBoxLayout();
hbox->addWidget(new QLabel(i18n("Sort method:"), panelGrp));
KONFIGURATOR_NAME_VALUE_PAIR sortMethods[] = {{ i18n("Alphabetical"), QString::number(KrViewProperties::Alphabetical) },
{ i18n("Alphabetical and numbers"), QString::number(KrViewProperties::AlphabeticalNumbers) },
{ i18n("Character code"), QString::number(KrViewProperties::CharacterCode) },
{ i18n("Character code and numbers"), QString::number(KrViewProperties::CharacterCodeNumbers) },
{ i18nc("Krusader sort", "Krusader"), QString::number(KrViewProperties::Krusader) }
};
KonfiguratorComboBox *cmb = createComboBox("Look&Feel", "Sort method", QString::number(_DefaultSortMethod),
sortMethods, 5, panelGrp, true, false, PAGE_VIEW);
hbox->addWidget(cmb);
hbox->addWidget(createSpacer(panelGrp));
panelGrid->addLayout(hbox, 5, 0);
// ------------------------ Sort Options ----------------------------------
KONFIGURATOR_CHECKBOX_PARAM sortSettings[] =
// cfg_class, cfg_name, default, text, restart, tooltip
{
{"Look&Feel", "Case Sensative Sort", _CaseSensativeSort, i18n("Case sensitive sorting"), true,
i18n("All files beginning with capital letters appear before files beginning with non-capital letters (UNIX default).") },
{"Look&Feel", "Show Directories First", true, i18n("Show folders first"), true, nullptr },
{"Look&Feel", "Always sort dirs by name", false, i18n("Always sort dirs by name"), true,
i18n("Folders are sorted by name, regardless of the sort column.") },
{"Look&Feel", "Locale Aware Sort", true, i18n("Locale aware sorting"), true,
i18n("The sorting is performed in a locale- and also platform-dependent manner. Can be slow.") },
};
KonfiguratorCheckBoxGroup *sortSett = createCheckBoxGroup(2, 0, sortSettings,
4 /*count*/, panelGrp, PAGE_VIEW);
sortSett->find("Show Directories First")->addDep(sortSett->find("Always sort dirs by name"));
panelGrid->addWidget(sortSett, 6, 0, 1, 2);
// ----------------------------------------------------------------------------------
// ---------------------------- View modes -----------------------------------------
// ----------------------------------------------------------------------------------
panelGrp = createFrame(i18n("View modes"), tab_panel);
panelLayout->addWidget(panelGrp, 1, 0);
panelGrid = createGridLayout(panelGrp);
// -------------------- Default Panel Type ----------------------------------
hbox = new QHBoxLayout();
hbox->addWidget(new QLabel(i18n("Default view mode:"), panelGrp));
QList views = KrViewFactory::registeredViews();
const int viewsSize = views.size();
auto *panelTypes = new KONFIGURATOR_NAME_VALUE_PAIR[ viewsSize ];
QString defType = QString('0');
for (int i = 0; i != viewsSize; i++) {
KrViewInstance * inst = views[ i ];
panelTypes[ i ].text = inst->description();
panelTypes[ i ].text.remove('&');
panelTypes[ i ].value = QString("%1").arg(inst->id());
if (inst->id() == KrViewFactory::defaultViewId())
defType = QString("%1").arg(inst->id());
}
cmb = createComboBox("Look&Feel", "Default Panel Type", defType, panelTypes, viewsSize, panelGrp, false, false, PAGE_VIEW);
hbox->addWidget(cmb);
hbox->addWidget(createSpacer(panelGrp));
delete [] panelTypes;
panelGrid->addLayout(hbox, 0, 0);
// ----- Individual Settings Per View Type ------------------------
auto *tabs_view = new QTabWidget(panelGrp);
panelGrid->addWidget(tabs_view, 11, 0);
for(int i = 0; i < views.count(); i++) {
QWidget *tab = new QWidget(tabs_view);
tabs_view->addTab(tab, views[i]->description());
setupView(views[i], tab);
}
}
// -----------------------------------------------------------------------------------
// -------------------------- Panel Toolbar TAB ----------------------------------
// -----------------------------------------------------------------------------------
void KgPanel::setupButtonsTab()
{
auto *scrollArea = new QScrollArea(tabWidget);
QWidget *tab = new QWidget(scrollArea);
scrollArea->setFrameStyle(QFrame::NoFrame);
scrollArea->setWidget(tab);
scrollArea->setWidgetResizable(true);
tabWidget->addTab(scrollArea, i18n("Buttons"));
QBoxLayout * tabLayout = new QVBoxLayout(tab);
tabLayout->setSpacing(6);
tabLayout->setContentsMargins(11, 11, 11, 11);
KONFIGURATOR_CHECKBOX_PARAM buttonsParams[] =
// cfg_class cfg_name default text restart tooltip
{
{"ListPanelButtons", "Icons", false, i18n("Toolbar buttons have icons"), true, "" },
{"Look&Feel", "Media Button Visible", true, i18n("Show Media Button"), true , i18n("The media button will be visible.") },
{"Look&Feel", "Back Button Visible", false, i18n("Show Back Button"), true , "Goes back in history." },
{"Look&Feel", "Forward Button Visible", false, i18n("Show Forward Button"), true , "Goes forward in history." },
{"Look&Feel", "History Button Visible", true, i18n("Show History Button"), true , i18n("The history button will be visible.") },
{"Look&Feel", "Bookmarks Button Visible", true, i18n("Show Bookmarks Button"), true , i18n("The bookmarks button will be visible.") },
{"Look&Feel", "Panel Toolbar visible", _PanelToolBar, i18n("Show Panel Toolbar"), true, i18n("The panel toolbar will be visible.") },
};
buttonsCheckboxes = createCheckBoxGroup(1, 0, buttonsParams, 7/*count*/, tab, PAGE_PANELTOOLBAR);
connect(buttonsCheckboxes->find("Panel Toolbar visible"), &KonfiguratorCheckBox::stateChanged, this, &KgPanel::slotEnablePanelToolbar);
tabLayout->addWidget(buttonsCheckboxes, 0, nullptr);
QGroupBox * panelToolbarGrp = createFrame(i18n("Visible Panel Toolbar buttons"), tab);
QGridLayout * panelToolbarGrid = createGridLayout(panelToolbarGrp);
KONFIGURATOR_CHECKBOX_PARAM panelToolbarButtonsParams[] = {
// cfg_class cfg_name default text restart tooltip
{"Look&Feel", "Equal Button Visible", _cdOther, i18n("Equal button (=)"), true , i18n("Changes the panel folder to the other panel folder.") },
{"Look&Feel", "Up Button Visible", _cdUp, i18n("Up button (..)"), true , i18n("Changes the panel folder to the parent folder.") },
{"Look&Feel", "Home Button Visible", _cdHome, i18n("Home button (~)"), true , i18n("Changes the panel folder to the home folder.") },
{"Look&Feel", "Root Button Visible", _cdRoot, i18n("Root button (/)"), true , i18n("Changes the panel folder to the root folder.") },
{"Look&Feel", "SyncBrowse Button Visible", _syncBrowseButton, i18n("Toggle-button for sync-browsing"), true , i18n("Each folder change in the panel is also performed in the other panel.") },
};
panelToolbarButtonsCheckboxes = createCheckBoxGroup(1, 0, panelToolbarButtonsParams,
sizeof(panelToolbarButtonsParams) / sizeof(*panelToolbarButtonsParams),
panelToolbarGrp, PAGE_PANELTOOLBAR);
panelToolbarGrid->addWidget(panelToolbarButtonsCheckboxes, 0, 0);
tabLayout->addWidget(panelToolbarGrp, 1, nullptr);
// Enable panel toolbar checkboxes
slotEnablePanelToolbar();
}
// ---------------------------------------------------------------------------
// -------------------------- Mouse TAB ----------------------------------
// ---------------------------------------------------------------------------
void KgPanel::setupMouseModeTab()
{
auto *scrollArea = new QScrollArea(tabWidget);
QWidget *tab_mouse = new QWidget(scrollArea);
scrollArea->setFrameStyle(QFrame::NoFrame);
scrollArea->setWidget(tab_mouse);
scrollArea->setWidgetResizable(true);
tabWidget->addTab(scrollArea, i18n("Selection Mode"));
auto *mouseLayout = new QGridLayout(tab_mouse);
mouseLayout->setSpacing(6);
mouseLayout->setContentsMargins(11, 11, 11, 11);
// -------------- General -----------------
QGroupBox *mouseGeneralGroup = createFrame(i18n("General"), tab_mouse);
QGridLayout *mouseGeneralGrid = createGridLayout(mouseGeneralGroup);
mouseGeneralGrid->setSpacing(0);
mouseGeneralGrid->setContentsMargins(5, 5, 5, 5);
KONFIGURATOR_NAME_VALUE_TIP mouseSelection[] = {
// name value tooltip
{ i18n("Krusader Mode"), "0", i18n("Both keys allow selecting files. To select more than one file, hold the Ctrl key and click the left mouse button. Right-click menu is invoked using a short click on the right mouse button.") },
{ i18n("Konqueror Mode"), "1", i18n("Pressing the left mouse button selects files - you can click and select multiple files. Right-click menu is invoked using a short click on the right mouse button.") },
{ i18n("Total-Commander Mode"), "2", i18n("The left mouse button does not select, but sets the current file without affecting the current selection. The right mouse button selects multiple files and the right-click menu is invoked by pressing and holding the right mouse button.") },
{ i18n("Ergonomic Mode"), "4", i18n("The left mouse button does not select, but sets the current file without affecting the current selection. The right mouse button invokes the context-menu. You can select with Ctrl key and the left button.") },
{ i18n("Custom Selection Mode"), "3", i18n("Design your own selection mode.") }
};
mouseRadio = createRadioButtonGroup("Look&Feel", "Mouse Selection", "0", 1, 5, mouseSelection, 5, mouseGeneralGroup, true, PAGE_MOUSE);
mouseRadio->layout()->setContentsMargins(0, 0, 0, 0);
mouseGeneralGrid->addWidget(mouseRadio, 0, 0);
for (int i = 0; i != mouseRadio->count(); i++)
connect(mouseRadio->find(i), &QRadioButton::clicked, this, &KgPanel::slotSelectionModeChanged);
mouseLayout->addWidget(mouseGeneralGroup, 0, 0);
// -------------- Details -----------------
QGroupBox *mouseDetailGroup = createFrame(i18n("Details"), tab_mouse);
QGridLayout *mouseDetailGrid = createGridLayout(mouseDetailGroup);
mouseDetailGrid->setSpacing(0);
mouseDetailGrid->setContentsMargins(5, 5, 5, 5);
KONFIGURATOR_NAME_VALUE_TIP singleOrDoubleClick[] = {
// name value tooltip
{ i18n("Double-click selects (classic)"), "0", i18n("A single click on a file will select and focus, a double click opens the file or steps into the folder.") },
{ i18n("Obey global selection policy"), "1", i18n("Use global setting:
Plasma System Settings -> Input Devices -> Mouse
") }
};
KonfiguratorRadioButtons *clickRadio = createRadioButtonGroup("Look&Feel", "Single Click Selects", "0", 1, 0, singleOrDoubleClick, 2, mouseDetailGroup, true, PAGE_MOUSE);
clickRadio->layout()->setContentsMargins(0, 0, 0, 0);
mouseDetailGrid->addWidget(clickRadio, 0, 0);
KONFIGURATOR_CHECKBOX_PARAM mouseCheckboxesParam[] = {
// {cfg_class, cfg_name, default
// text, restart,
// tooltip }
{"Custom Selection Mode", "QT Selection", _QtSelection,
i18n("Based on KDE's selection mode"), true,
i18n("If checked, use a mode based on KDE's style.") },
{"Custom Selection Mode", "Left Selects", _LeftSelects,
i18n("Left mouse button selects"), true,
i18n("If checked, left clicking an item will select it.") },
{"Custom Selection Mode", "Left Preserves", _LeftPreserves,
i18n("Left mouse button preserves selection"), true,
i18n("If checked, left clicking an item will select it, but will not unselect other, already selected items.") },
{"Custom Selection Mode", "ShiftCtrl Left Selects", _ShiftCtrlLeft,
i18n("Shift/Ctrl-Left mouse button selects"), true,
i18n("If checked, Shift/Ctrl left clicking will select items.\nNote: this is meaningless if 'Left Button Selects' is checked.") },
{"Custom Selection Mode", "Right Selects", _RightSelects,
i18n("Right mouse button selects"), true,
i18n("If checked, right clicking an item will select it.") },
{"Custom Selection Mode", "Right Preserves", _RightPreserves,
i18n("Right mouse button preserves selection"), true,
i18n("If checked, right clicking an item will select it, but will not unselect other, already selected items.") },
{"Custom Selection Mode", "ShiftCtrl Right Selects", _ShiftCtrlRight,
i18n("Shift/Ctrl-Right mouse button selects"), true,
i18n("If checked, Shift/Ctrl right clicking will select items.\nNote: this is meaningless if 'Right Button Selects' is checked.") },
{"Custom Selection Mode", "Space Moves Down", _SpaceMovesDown,
i18n("Spacebar moves down"), true,
i18n("If checked, pressing the spacebar will select the current item and move down.\nOtherwise, current item is selected, but remains the current item.") },
{"Custom Selection Mode", "Space Calc Space", _SpaceCalcSpace,
i18n("Spacebar calculates disk space"), true,
i18n("If checked, pressing the spacebar while the current item is a folder, will (except from selecting the folder)\ncalculate space occupied of the folder (recursively).") },
{"Custom Selection Mode", "Insert Moves Down", _InsertMovesDown,
i18n("Insert moves down"), true,
i18n("If checked, pressing Insert will select the current item, and move down to the next item.\nOtherwise, current item is not changed.") },
{"Custom Selection Mode", "Immediate Context Menu", _ImmediateContextMenu,
i18n("Right clicking pops context menu immediately"), true,
i18n("If checked, right clicking will result in an immediate showing of the context menu.\nOtherwise, user needs to click and hold the right mouse button for 500ms.") },
};
mouseCheckboxes = createCheckBoxGroup(1, 0, mouseCheckboxesParam, 11 /*count*/, mouseDetailGroup, PAGE_MOUSE);
mouseDetailGrid->addWidget(mouseCheckboxes, 1, 0);
for (int i = 0; i < mouseCheckboxes->count(); i++)
connect(mouseCheckboxes->find(i), &KonfiguratorCheckBox::clicked, this, &KgPanel::slotMouseCheckBoxChanged);
mouseLayout->addWidget(mouseDetailGroup, 0, 1, 2, 1);
// Disable the details-button if not in custom-mode
slotSelectionModeChanged();
// -------------- Preview -----------------
QGroupBox *mousePreviewGroup = createFrame(i18n("Preview"), tab_mouse);
QGridLayout *mousePreviewGrid = createGridLayout(mousePreviewGroup);
// TODO preview
mousePreview = new KrTreeWidget(mousePreviewGroup);
mousePreviewGrid->addWidget(mousePreview, 0 , 0);
mousePreviewGroup->setEnabled(false); // TODO re-enable once the preview is implemented
// ------------------------------------------
mouseLayout->addWidget(mousePreviewGroup, 1, 0);
}
// ---------------------------------------------------------------------------
// -------------------------- Media Menu TAB ----------------------------------
// ---------------------------------------------------------------------------
void KgPanel::setupMediaMenuTab()
{
auto *scrollArea = new QScrollArea(tabWidget);
QWidget *tab = new QWidget(scrollArea);
scrollArea->setFrameStyle(QFrame::NoFrame);
scrollArea->setWidget(tab);
scrollArea->setWidgetResizable(true);
tabWidget->addTab(scrollArea, i18n("Media Menu"));
QBoxLayout * tabLayout = new QVBoxLayout(tab);
tabLayout->setSpacing(6);
tabLayout->setContentsMargins(11, 11, 11, 11);
KONFIGURATOR_CHECKBOX_PARAM mediaMenuParams[] = {
// cfg_class cfg_name default text restart tooltip
{"MediaMenu", "ShowPath", true, i18n("Show Mount Path"), false, nullptr },
{"MediaMenu", "ShowFSType", true, i18n("Show File System Type"), false, nullptr },
};
KonfiguratorCheckBoxGroup *mediaMenuCheckBoxes =
createCheckBoxGroup(1, 0, mediaMenuParams,
sizeof(mediaMenuParams) / sizeof(*mediaMenuParams),
tab, PAGE_MEDIA_MENU);
tabLayout->addWidget(mediaMenuCheckBoxes, 0, nullptr);
auto *showSizeHBox = new QHBoxLayout();
showSizeHBox->addWidget(new QLabel(i18n("Show Size:"), tab));
KONFIGURATOR_NAME_VALUE_PAIR showSizeValues[] = {
{ i18nc("setting 'show size'", "Always"), "Always" },
{ i18nc("setting 'show size'", "When Device has no Label"), "WhenNoLabel" },
{ i18nc("setting 'show size'", "Never"), "Never" },
};
KonfiguratorComboBox *showSizeCmb =
createComboBox("MediaMenu", "ShowSize",
"Always", showSizeValues,
sizeof(showSizeValues) / sizeof(*showSizeValues),
tab, false, false, PAGE_MEDIA_MENU);
showSizeHBox->addWidget(showSizeCmb);
showSizeHBox->addStretch();
tabLayout->addLayout(showSizeHBox);
tabLayout->addStretch();
}
void KgPanel::slotEnablePanelToolbar()
{
bool enableTB = buttonsCheckboxes->find("Panel Toolbar visible")->isChecked();
panelToolbarButtonsCheckboxes->find("Root Button Visible")->setEnabled(enableTB);
panelToolbarButtonsCheckboxes->find("Home Button Visible")->setEnabled(enableTB);
panelToolbarButtonsCheckboxes->find("Up Button Visible")->setEnabled(enableTB);
panelToolbarButtonsCheckboxes->find("Equal Button Visible")->setEnabled(enableTB);
panelToolbarButtonsCheckboxes->find("SyncBrowse Button Visible")->setEnabled(enableTB);
}
void KgPanel::slotSelectionModeChanged()
{
KrSelectionMode *selectionMode =
KrSelectionMode::getSelectionHandlerForMode(mouseRadio->selectedValue());
if (selectionMode == nullptr) //User mode
return;
selectionMode->init();
mouseCheckboxes->find("QT Selection")->setChecked(selectionMode->useQTSelection());
mouseCheckboxes->find("Left Selects")->setChecked(selectionMode->leftButtonSelects());
mouseCheckboxes->find("Left Preserves")->setChecked(selectionMode->leftButtonPreservesSelection());
mouseCheckboxes->find("ShiftCtrl Left Selects")->setChecked(selectionMode->shiftCtrlLeftButtonSelects());
mouseCheckboxes->find("Right Selects")->setChecked(selectionMode->rightButtonSelects());
mouseCheckboxes->find("Right Preserves")->setChecked(selectionMode->rightButtonPreservesSelection());
mouseCheckboxes->find("ShiftCtrl Right Selects")->setChecked(selectionMode->shiftCtrlRightButtonSelects());
mouseCheckboxes->find("Space Moves Down")->setChecked(selectionMode->spaceMovesDown());
mouseCheckboxes->find("Space Calc Space")->setChecked(selectionMode->spaceCalculatesDiskSpace());
mouseCheckboxes->find("Insert Moves Down")->setChecked(selectionMode->insertMovesDown());
mouseCheckboxes->find("Immediate Context Menu")->setChecked(selectionMode->showContextMenu() == -1);
}
void KgPanel::slotMouseCheckBoxChanged()
{
mouseRadio->selectButton("3"); //custom selection mode
}
int KgPanel::activeSubPage()
{
return tabWidget->currentIndex();
}
diff --git a/krusader/Panel/listpanel.cpp b/krusader/Panel/listpanel.cpp
index 515a6f71..b3b92f74 100644
--- a/krusader/Panel/listpanel.cpp
+++ b/krusader/Panel/listpanel.cpp
@@ -1,1376 +1,1376 @@
/*****************************************************************************
* Copyright (C) 2000 Shie Erlich *
* Copyright (C) 2000 Rafi Yanai *
* Copyright (C) 2004-2019 Krusader Krew [https://krusader.org] *
* *
* This file is part of Krusader [https://krusader.org]. *
* *
* Krusader 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. *
* *
* Krusader 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 Krusader. If not, see [http://www.gnu.org/licenses/]. *
*****************************************************************************/
#include "listpanel.h"
// QtCore
#include
#include
#include
#include
#include
#include
#include
// QtGui
#include
#include
#include
#include
#include
#include
#include
#include
// QtWidgets
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include "dirhistoryqueue.h"
#include "krcolorcache.h"
#include "krerrordisplay.h"
#include "krlayoutfactory.h"
#include "krpreviewpopup.h"
#include "krsearchbar.h"
#include "listpanelactions.h"
#include "panelcontextmenu.h"
#include "panelfunc.h"
#include "sidebar.h"
#include "viewactions.h"
#include "PanelView/krview.h"
#include "PanelView/krviewfactory.h"
#include "PanelView/krviewitem.h"
#include "../defaults.h"
#include "../icon.h"
#include "../krservices.h"
#include "../krslots.h"
#include "../krusader.h"
#include "../krusaderview.h"
#include "../Archive/krarchandler.h"
#include "../BookMan/krbookmarkbutton.h"
#include "../FileSystem/fileitem.h"
#include "../FileSystem/filesystem.h"
#include "../FileSystem/krpermhandler.h"
#include "../FileSystem/sizecalculator.h"
#include "../Dialogs/krdialogs.h"
#include "../Dialogs/krspwidgets.h"
#include "../Dialogs/krsqueezedtextlabel.h"
#include "../Dialogs/percentalsplitter.h"
#include "../Dialogs/popularurls.h"
#include "../GUI/dirhistorybutton.h"
#include "../GUI/kcmdline.h"
#include "../GUI/mediabutton.h"
#include "../MountMan/kmountman.h"
#include "../UserAction/useractionpopupmenu.h"
class ActionButton : public QToolButton
{
public:
ActionButton(QWidget *parent, ListPanel *panel, QAction *action, const QString& text = QString()) :
QToolButton(parent), panel(panel), action(action) {
setText(text);
setAutoRaise(true);
if(KConfigGroup(krConfig, "ListPanelButtons").readEntry("Icons", false) || text.isEmpty())
setIcon(action->icon());
setToolTip(action->toolTip());
}
protected:
void mousePressEvent(QMouseEvent *) override {
panel->slotFocusOnMe();
action->trigger();
}
ListPanel *panel;
QAction *action;
};
/////////////////////////////////////////////////////
// The list panel constructor //
/////////////////////////////////////////////////////
ListPanel::ListPanel(QWidget *parent, AbstractPanelManager *manager, const KConfigGroup &cfg)
: QWidget(parent), KrPanel(manager, this, new ListPanelFunc(this)), panelType(-1),
colorMask(255), compareMode(false), previewJob(nullptr), inlineRefreshJob(nullptr),
searchBar(nullptr), cdRootButton(nullptr), cdUpButton(nullptr), sidebarButton(nullptr),
sidebar(nullptr), fileSystemError(nullptr), _tabState(TabState::DEFAULT)
{
if(cfg.isValid())
panelType = cfg.readEntry("Type", -1);
if (panelType == -1)
panelType = defaultPanelType();
_actions = krApp->listPanelActions();
setAcceptDrops(true);
QHash widgets;
#define ADD_WIDGET(widget) widgets.insert(#widget, widget);
// media button
mediaButton = new MediaButton(this);
connect(mediaButton, &MediaButton::aboutToShow, this, [=]() { slotFocusOnMe(); });
connect(mediaButton, &MediaButton::openUrl, [=](const QUrl & _t1) { func->openUrl(_t1); });
connect(mediaButton, &MediaButton::newTab, this, [=](const QUrl &url) { newTab(url); });
ADD_WIDGET(mediaButton);
// status bar
status = new KrSqueezedTextLabel(this);
KConfigGroup group(krConfig, "Look&Feel");
status->setFont(group.readEntry("Filelist Font", _FilelistFont));
status->setAutoFillBackground(false);
status->setText(""); // needed for initialization code!
status->setWhatsThis(i18n("The statusbar displays information about the filesystem "
"which holds your current folder: total size, free space, "
"type of filesystem, etc."));
ADD_WIDGET(status);
// back button
backButton = new ActionButton(this, this, _actions->actHistoryBackward);
ADD_WIDGET(backButton);
// forward button
forwardButton = new ActionButton(this, this, _actions->actHistoryForward);
ADD_WIDGET(forwardButton);
// ... create the history button
historyButton = new DirHistoryButton(func->history, this);
connect(historyButton, &DirHistoryButton::aboutToShow, this, [=]() { slotFocusOnMe(); });
connect(historyButton, &DirHistoryButton::gotoPos, func, &ListPanelFunc::historyGotoPos);
ADD_WIDGET(historyButton);
// bookmarks button
bookmarksButton = new KrBookmarkButton(this);
connect(bookmarksButton, &KrBookmarkButton::aboutToShow, this, [=]() { slotFocusOnMe(); });
connect(bookmarksButton, &KrBookmarkButton::openUrl, [=](const QUrl & _t1) { func->openUrl(_t1); });
bookmarksButton->setWhatsThis(i18n("Open menu with bookmarks. You can also add "
"current location to the list, edit bookmarks "
"or add subfolder to the list."));
ADD_WIDGET(bookmarksButton);
// url input field
urlNavigator = new KUrlNavigator(new KFilePlacesModel(this), QUrl(), this);
urlNavigator->setWhatsThis(i18n("Name of folder where you are. You can also "
"enter name of desired location to move there. "
"Use of Net protocols like ftp or fish is possible."));
// handle certain key events here in event filter
urlNavigator->editor()->installEventFilter(this);
urlNavigator->setUrlEditable(isNavigatorEditModeSet());
urlNavigator->setShowFullPath(group.readEntry("Navigator Full Path", false));
connect(urlNavigator, &KUrlNavigator::returnPressed, this, [=]() { slotFocusOnMe(); });
connect(urlNavigator, &KUrlNavigator::urlChanged, this, &ListPanel::slotNavigatorUrlChanged);
connect(urlNavigator->editor()->lineEdit(), &QLineEdit::editingFinished, this, &ListPanel::resetNavigatorMode);
connect(urlNavigator, &KUrlNavigator::tabRequested, this, [=](const QUrl &url) { ListPanel::newTab(url); });
connect(urlNavigator, &KUrlNavigator::urlsDropped, this, QOverload::of(&ListPanel::handleDrop));
ADD_WIDGET(urlNavigator);
// toolbar
QWidget * toolbar = new QWidget(this);
auto * toolbarLayout = new QHBoxLayout(toolbar);
toolbarLayout->setContentsMargins(0, 0, 0, 0);
toolbarLayout->setSpacing(0);
ADD_WIDGET(toolbar);
fileSystemError = new KrErrorDisplay(this);
fileSystemError->setWordWrap(true);
fileSystemError->hide();
ADD_WIDGET(fileSystemError);
// client area
clientArea = new QWidget(this);
auto *clientLayout = new QVBoxLayout(clientArea);
clientLayout->setSpacing(0);
clientLayout->setContentsMargins(0, 0, 0, 0);
ADD_WIDGET(clientArea);
// totals label
totals = new KrSqueezedTextLabel(this);
totals->setFont(group.readEntry("Filelist Font", _FilelistFont));
totals->setAutoFillBackground(false);
totals->setWhatsThis(i18n("The totals bar shows how many files exist, "
"how many selected and the bytes math"));
ADD_WIDGET(totals);
// free space label
freeSpace = new KrSqueezedTextLabel(this);
freeSpace->setFont(group.readEntry("Filelist Font", _FilelistFont));
freeSpace->setAutoFillBackground(false);
freeSpace->setText("");
freeSpace->setAlignment(Qt::AlignRight | Qt::AlignVCenter);
ADD_WIDGET(freeSpace);
// progress indicator and cancel button for the quick calc size
quickSizeCalcProgress = new QProgressBar(this);
quickSizeCalcProgress->hide();
ADD_WIDGET(quickSizeCalcProgress);
cancelQuickSizeCalcButton = new QToolButton(this);
cancelQuickSizeCalcButton->hide();
cancelQuickSizeCalcButton->setIcon(Icon("dialog-cancel"));
- cancelQuickSizeCalcButton->setToolTip(i18n("Cancel directory space calculation"));
+ cancelQuickSizeCalcButton->setToolTip(i18n("Cancel folder space calculation"));
ADD_WIDGET(cancelQuickSizeCalcButton);
// progress indicator for the preview job
previewProgress = new QProgressBar(this);
previewProgress->hide();
ADD_WIDGET(previewProgress);
// a cancel button for the filesystem refresh and preview job
cancelProgressButton = new QToolButton(this);
cancelProgressButton->hide();
cancelProgressButton->setIcon(Icon("dialog-cancel"));
connect(cancelProgressButton, &QToolButton::clicked, this, &ListPanel::cancelProgress);
ADD_WIDGET(cancelProgressButton);
// button for changing the panel sidebar position in the panel
sidebarPositionButton = new QToolButton(this);
sidebarPositionButton->hide();
sidebarPositionButton->setAutoRaise(true);
sidebarPositionButton->setIcon(Icon("exchange-positions"));
sidebarPositionButton->setToolTip(i18n("Move Sidebar clockwise"));
connect(sidebarPositionButton, &QToolButton::clicked, [this]() {
// moving position clockwise
setSidebarPosition((sidebarPosition() + 1) % 4); });
ADD_WIDGET(sidebarPositionButton);
// a quick button to open the sidebar
sidebarButton = new QToolButton(this);
sidebarButton->setAutoRaise(true);
sidebarButton->setIcon(Icon("arrow-up"));
connect(sidebarButton, &QToolButton::clicked, this, &ListPanel::toggleSidebar);
sidebarButton->setToolTip(i18n("Open the Sidebar"));
ADD_WIDGET(sidebarButton);
#undef ADD_WIDGET
// toolbar buttons
cdOtherButton = new ActionButton(toolbar, this, _actions->actCdToOther, "=");
toolbarLayout->addWidget(cdOtherButton);
cdUpButton = new ActionButton(toolbar, this, _actions->actDirUp, "..");
toolbarLayout->addWidget(cdUpButton);
cdHomeButton = new ActionButton(toolbar, this, _actions->actHome, "~");
toolbarLayout->addWidget(cdHomeButton);
cdRootButton = new ActionButton(toolbar, this, _actions->actRoot, "/");
toolbarLayout->addWidget(cdRootButton);
// create the button for sync-browsing
syncBrowseButton = new QToolButton(toolbar);
syncBrowseButton->setIcon(Icon("kr_syncbrowse_off"));
syncBrowseButton->setCheckable(true);
const QString syncBrowseText = i18n("This button toggles the sync-browse mode.\n"
"When active, each folder change is performed in the\n"
"active and inactive panel - if possible.");
syncBrowseButton->setText(syncBrowseText);
syncBrowseButton->setToolTip(syncBrowseText);
connect(syncBrowseButton, &QToolButton::toggled, [=](bool checked) {
syncBrowseButton->setIcon(
Icon(checked ? "kr_syncbrowse_on" : "kr_syncbrowse_off"));
});
syncBrowseButton->setAutoRaise(true);
toolbarLayout->addWidget(syncBrowseButton);
setButtons();
// create a splitter to hold the view and the sidebar
sidebarSplitter = new PercentalSplitter(clientArea);
sidebarSplitter->setChildrenCollapsible(true);
sidebarSplitter->setOrientation(Qt::Horizontal);
// expand vertical if splitter orientation is horizontal
QSizePolicy sizePolicy = sidebarSplitter->sizePolicy();
sizePolicy.setVerticalPolicy(QSizePolicy::Expanding);
sidebarSplitter->setSizePolicy(sizePolicy);
clientLayout->addWidget(sidebarSplitter);
// view
createView();
// search (in folder) bar
searchBar = new KrSearchBar(view, clientArea);
searchBar->hide();
bool top = group.readEntry("Quicksearch Position", "bottom") == "top";
clientLayout->insertWidget(top ? 0 : -1, searchBar);
// create the layout
KrLayoutFactory fact(this, widgets);
QLayout *layout = fact.createLayout();
if(!layout) { // fallback: create a layout by ourself
auto *v = new QVBoxLayout;
v->setContentsMargins(0, 0, 0, 0);
v->setSpacing(0);
auto *h = new QHBoxLayout;
h->setContentsMargins(0, 0, 0, 0);
h->setSpacing(0);
h->addWidget(urlNavigator);
h->addWidget(toolbar);
h->addStretch();
v->addLayout(h);
h = new QHBoxLayout;
h->setContentsMargins(0, 0, 0, 0);
h->setSpacing(0);
h->addWidget(mediaButton);
h->addWidget(status);
h->addWidget(backButton);
h->addWidget(forwardButton);
h->addWidget(historyButton);
h->addWidget(bookmarksButton);
v->addLayout(h);
v->addWidget(fileSystemError);
v->addWidget(clientArea);
h = new QHBoxLayout;
h->setContentsMargins(0, 0, 0, 0);
h->setSpacing(0);
h->addWidget(totals);
h->addWidget(freeSpace);
h->addWidget(quickSizeCalcProgress);
h->addWidget(cancelQuickSizeCalcButton);
h->addWidget(previewProgress);
h->addWidget(cancelProgressButton);
h->addWidget(sidebarButton);
v->addLayout(h);
layout = v;
}
setLayout(layout);
connect(&KrColorCache::getColorCache(), &KrColorCache::colorsRefreshed, this, &ListPanel::slotRefreshColors);
connect(krApp, &Krusader::shutdown, this, &ListPanel::cancelProgress);
}
ListPanel::~ListPanel()
{
cancelProgress();
delete view;
view = nullptr;
delete func;
delete status;
delete bookmarksButton;
delete totals;
delete urlNavigator;
delete cdRootButton;
delete cdHomeButton;
delete cdUpButton;
delete cdOtherButton;
delete syncBrowseButton;
// delete layout;
}
void ListPanel::reparent(QWidget *parent, AbstractPanelManager *manager)
{
setParent(parent);
_manager = manager;
}
int ListPanel::defaultPanelType()
{
KConfigGroup group(krConfig, "Look&Feel");
return group.readEntry("Default Panel Type", KrViewFactory::defaultViewId());
}
bool ListPanel::isNavigatorEditModeSet()
{
KConfigGroup group(krConfig, "Look&Feel");
return group.readEntry("Navigator Edit Mode", false);
}
void ListPanel::createView()
{
view = KrViewFactory::createView(panelType, sidebarSplitter, krConfig);
view->init();
view->setMainWindow(krApp);
// KrViewFactory may create a different view type than requested
panelType = view->instance()->id();
if(this == ACTIVE_PANEL)
view->prepareForActive();
else
view->prepareForPassive();
view->refreshColors();
sidebarSplitter->insertWidget(sidebarPosition() < 2 ? 1 : 0, view->widget());
view->widget()->installEventFilter(this);
connect(view->op(), &KrViewOperator::quickCalcSpace, func, &ListPanelFunc::quickCalcSpace);
connect(view->op(), &KrViewOperator::goHome, func, &ListPanelFunc::home);
connect(view->op(), &KrViewOperator::dirUp, func, &ListPanelFunc::dirUp);
connect(view->op(), &KrViewOperator::defaultDeleteFiles, func, &ListPanelFunc::defaultDeleteFiles);
connect(view->op(), &KrViewOperator::middleButtonClicked, this, QOverload::of(&ListPanel::newTab));
connect(view->op(), &KrViewOperator::currentChanged, this, &ListPanel::slotCurrentChanged);
connect(view->op(), &KrViewOperator::renameItem, func, QOverload::of(&ListPanelFunc::rename));
connect(view->op(), &KrViewOperator::executed, func, &ListPanelFunc::execute);
connect(view->op(), &KrViewOperator::goInside, func, &ListPanelFunc::goInside);
connect(view->op(), &KrViewOperator::needFocus, this, [=]() { slotFocusOnMe(); });
connect(view->op(), &KrViewOperator::selectionChanged, this, &ListPanel::slotUpdateTotals);
connect(view->op(), &KrViewOperator::itemDescription, krApp, &Krusader::statusBarUpdate);
connect(view->op(), &KrViewOperator::contextMenu, this, &ListPanel::popRightClickMenu);
connect(view->op(), &KrViewOperator::emptyContextMenu, this, &ListPanel::popEmptyRightClickMenu);
connect(view->op(), &KrViewOperator::letsDrag, this, &ListPanel::startDragging);
connect(view->op(), &KrViewOperator::gotDrop, this, [this](QDropEvent *event) {handleDrop(event, true); });
connect(view->op(), &KrViewOperator::previewJobStarted, this, &ListPanel::slotPreviewJobStarted);
connect(view->op(), &KrViewOperator::refreshActions, krApp->viewActions(), &ViewActions::refreshActions);
connect(view->op(), &KrViewOperator::currentChanged, func->history, &DirHistoryQueue::saveCurrentItem);
connect(view->op(), &KrViewOperator::goBack, func, &ListPanelFunc::historyBackward);
connect(view->op(), &KrViewOperator::goForward, func, &ListPanelFunc::historyForward);
view->setFiles(func->files());
func->refreshActions();
}
void ListPanel::changeType(int type)
{
if (panelType != type) {
QString current = view->getCurrentItem();
QList selection = view->selectedUrls();
bool filterApplysToDirs = view->properties()->filterApplysToDirs;
KrViewProperties::FilterSpec filter = view->filter();
FilterSettings filterSettings = view->properties()->filterSettings;
panelType = type;
KrView *oldView = view;
createView();
searchBar->setView(view);
delete oldView;
view->setFilter(filter, filterSettings, filterApplysToDirs);
view->setSelectionUrls(selection);
view->setCurrentItem(current);
view->makeItemVisible(view->getCurrentKrViewItem());
}
}
int ListPanel::getProperties()
{
int props = 0;
if (syncBrowseButton->isChecked()) {
props |= PROP_SYNC_BUTTON_ON;
}
if (isLocked()) {
props |= PROP_LOCKED;
} else if (isPinned()) {
props |= PROP_PINNED;
}
return props;
}
void ListPanel::setProperties(int prop)
{
syncBrowseButton->setChecked(prop & PROP_SYNC_BUTTON_ON);
if (prop & PROP_LOCKED) {
_tabState = TabState::LOCKED;
} else if (prop & PROP_PINNED) {
_tabState = TabState::PINNED;
} else {
_tabState = TabState::DEFAULT;
}
}
bool ListPanel::eventFilter(QObject * watched, QEvent * e)
{
if(view && watched == view->widget()) {
if(e->type() == QEvent::FocusIn && this != ACTIVE_PANEL && !isHidden())
slotFocusOnMe();
else if(e->type() == QEvent::ShortcutOverride) {
auto *ke = dynamic_cast(e);
if(ke->key() == Qt::Key_Escape && ke->modifiers() == Qt::NoModifier) {
// if the cancel refresh action has no shortcut assigned,
// we need this event ourselves to cancel refresh
if(_actions->actCancelRefresh->shortcut().isEmpty()) {
e->accept();
return true;
}
}
}
}
// handle URL navigator key events
else if(watched == urlNavigator->editor()) {
// override default shortcut for panel focus
if(e->type() == QEvent::ShortcutOverride) {
auto *ke = dynamic_cast(e);
if ((ke->key() == Qt::Key_Escape) && (ke->modifiers() == Qt::NoModifier)) {
e->accept(); // we will get the key press event now
return true;
}
} else if(e->type() == QEvent::KeyPress) {
auto *ke = dynamic_cast(e);
if ((ke->key() == Qt::Key_Down) && (ke->modifiers() == Qt::ControlModifier)) {
slotFocusOnMe();
return true;
} else if ((ke->key() == Qt::Key_Escape) && (ke->modifiers() == Qt::NoModifier)) {
// reset navigator
urlNavigator->editor()->setUrl(urlNavigator->locationUrl());
slotFocusOnMe();
return true;
}
}
}
return false;
}
void ListPanel::toggleSidebar()
{
if(!sidebar) {
sidebar = new Sidebar(sidebarSplitter);
// fix vertical grow of splitter (and entire window) if its content
// demands more space
QSizePolicy sizePolicy = sidebar->sizePolicy();
sizePolicy.setVerticalPolicy(QSizePolicy::Ignored);
sidebar->setSizePolicy(sizePolicy);
connect(this, &ListPanel::pathChanged, sidebar, &Sidebar::onPanelPathChange);
connect(sidebar, &Sidebar::urlActivated, SLOTS, &KRslots::refresh);
sidebarSplitter->insertWidget(0, sidebar);
}
if (sidebar->isHidden()) {
if (sidebarSplitterSizes.count() > 0) {
sidebarSplitter->setSizes(sidebarSplitterSizes);
} else { // on the first time, resize to 50%
QList lst;
lst << height() / 2 << height() / 2;
sidebarSplitter->setSizes(lst);
}
sidebar->show();
sidebarButton->setIcon(Icon("arrow-down"));
sidebarButton->setToolTip(i18n("Close the Sidebar"));
sidebarPositionButton->show();
} else {
sidebarSplitterSizes.clear();
sidebarSplitterSizes = sidebarSplitter->sizes();
sidebar->hide();
sidebarButton->setIcon(Icon("arrow-up"));
sidebarButton->setToolTip(i18n("Open the Sidebar"));
sidebarPositionButton->hide();
QList lst;
lst << height() << 0;
sidebarSplitter->setSizes(lst);
if (ACTIVE_PANEL)
ACTIVE_PANEL->gui->slotFocusOnMe();
}
}
QString ListPanel::lastLocalPath() const
{
return _lastLocalPath;
}
void ListPanel::setButtons()
{
KConfigGroup group(krConfig, "Look&Feel");
mediaButton->setVisible(group.readEntry("Media Button Visible", true));
backButton->setVisible(group.readEntry("Back Button Visible", false));
forwardButton->setVisible(group.readEntry("Forward Button Visible", false));
historyButton->setVisible(group.readEntry("History Button Visible", true));
bookmarksButton->setVisible(group.readEntry("Bookmarks Button Visible", true));
if (group.readEntry("Panel Toolbar visible", _PanelToolBar)) {
cdRootButton->setVisible(group.readEntry("Root Button Visible", _cdRoot));
cdHomeButton->setVisible(group.readEntry("Home Button Visible", _cdHome));
cdUpButton->setVisible(group.readEntry("Up Button Visible", _cdUp));
cdOtherButton->setVisible(group.readEntry("Equal Button Visible", _cdOther));
syncBrowseButton->setVisible(group.readEntry("SyncBrowse Button Visible", _syncBrowseButton));
} else {
cdRootButton->hide();
cdHomeButton->hide();
cdUpButton->hide();
cdOtherButton->hide();
syncBrowseButton->hide();
}
}
void ListPanel::slotUpdateTotals()
{
totals->setText(view->statistics());
}
void ListPanel::compareDirs(bool otherPanelToo)
{
// Performs a check in order to avoid that the next code is executed twice
if (otherPanelToo == true) {
// If both panels are showing the same directory
if (_manager->currentPanel()->virtualPath() == otherPanel()->virtualPath()) {
if (KMessageBox::warningContinueCancel(this,
i18n("Warning: The left and the right side are showing the same folder.")) != KMessageBox::Continue) {
return;
}
}
}
KConfigGroup pg(krConfig, "Private");
int compareMode = pg.readEntry("Compare Mode", 0);
KConfigGroup group(krConfig, "Look&Feel");
bool selectDirs = group.readEntry("Mark Dirs", false);
KrViewItem *item, *otherItem;
for (item = view->getFirst(); item != nullptr; item = view->getNext(item)) {
if (item->name() == "..")
continue;
for (otherItem = otherPanel()->view->getFirst(); otherItem != nullptr && otherItem->name() != item->name();
otherItem = otherPanel()->view->getNext(otherItem));
bool isSingle = (otherItem == nullptr), isDifferent = false, isNewer = false;
if (func->getFileItem(item)->isDir() && !selectDirs) {
item->setSelected(false);
continue;
}
if (otherItem) {
if (!func->getFileItem(item)->isDir())
isDifferent = otherPanel()->func->getFileItem(otherItem)->getSize() != func->getFileItem(item)->getSize();
isNewer = func->getFileItem(item)->getModificationTime() > otherPanel()->func->getFileItem(otherItem)->getModificationTime();
}
switch (compareMode) {
case 0:
item->setSelected(isNewer || isSingle);
break;
case 1:
item->setSelected(isNewer);
break;
case 2:
item->setSelected(isSingle);
break;
case 3:
item->setSelected(isDifferent || isSingle);
break;
case 4:
item->setSelected(isDifferent);
break;
}
}
view->updateView();
if (otherPanelToo)
otherPanel()->gui->compareDirs(false);
}
void ListPanel::slotRefreshColors()
{
view->refreshColors();
emit signalRefreshColors(this == ACTIVE_PANEL);
}
void ListPanel::slotFocusOnMe(bool focus)
{
if (focus && _manager->currentPanel() != this) {
// ignore focus request if this panel is not shown
return;
}
krApp->setUpdatesEnabled(false);
if(focus) {
emit activate();
_actions->activePanelChanged();
func->refreshActions();
slotCurrentChanged(view->getCurrentKrViewItem());
view->prepareForActive();
otherPanel()->gui->slotFocusOnMe(false);
} else {
// in case a new url was entered but not refreshed to,
// reset url navigator to the current url
setNavigatorUrl(virtualPath());
view->prepareForPassive();
}
urlNavigator->setActive(focus);
slotRefreshColors();
krApp->setUpdatesEnabled(true);
}
// this is used to start the panel
//////////////////////////////////////////////////////////////////
void ListPanel::start(const QUrl &url)
{
QUrl startUrl(url);
if (!startUrl.isValid())
startUrl = QUrl::fromLocalFile(ROOT_DIR);
_lastLocalPath = startUrl.isLocalFile() ? startUrl.path() : ROOT_DIR;
func->openUrl(startUrl);
setJumpBack(startUrl);
}
void ListPanel::slotStartUpdate(bool directoryChange)
{
if (inlineRefreshJob)
inlineRefreshListResult(nullptr);
setCursor(Qt::BusyCursor);
const QUrl currentUrl = virtualPath();
if (directoryChange) {
if (this == ACTIVE_PANEL) {
slotFocusOnMe();
}
if (currentUrl.isLocalFile())
_lastLocalPath = currentUrl.path();
setNavigatorUrl(currentUrl);
emit pathChanged(currentUrl);
krApp->popularUrls()->addUrl(currentUrl);
searchBar->hideBar();
}
if (compareMode)
otherPanel()->view->refresh();
// return cursor to normal arrow
setCursor(Qt::ArrowCursor);
slotUpdateTotals();
}
void ListPanel::updateFilesystemStats(const QString &metaInfo, const QString &fsType,
KIO::filesize_t total, KIO::filesize_t free)
{
QString statusText, mountPoint, freeSpaceText;
if (!metaInfo.isEmpty()) {
statusText = metaInfo;
mountPoint = freeSpaceText = "";
} else {
const int perc = total == 0 ? 0 : (int)(((float)free / (float)total) * 100.0);
mountPoint = func->files()->mountPoint();
statusText = i18nc("%1=free space,%2=total space,%3=percentage of usage, "
"%4=mountpoint,%5=filesystem type",
"%1 free out of %2 (%3%) on %4 [(%5)]", KIO::convertSize(free),
KIO::convertSize(total), perc, mountPoint, fsType);
freeSpaceText = " " + i18n("%1 free", KIO::convertSize(free));
}
status->setText(statusText);
freeSpace->setText(freeSpaceText);
mediaButton->updateIcon(mountPoint);
}
void ListPanel::handleDrop(QDropEvent *event, bool onView)
{
// check what was dropped
const QList urls = KUrlMimeData::urlsFromMimeData(event->mimeData());
if (urls.isEmpty()) {
event->ignore(); // not for us to handle!
return;
}
// find dropping destination
QString destinationDir = "";
const bool dragFromThisPanel = event->source() == this;
const KrViewItem *item = onView ? view->getKrViewItemAt(event->pos()) : nullptr;
if (item) {
const FileItem *file = item->getFileItem();
if (file && !file->isDir() && dragFromThisPanel) {
event->ignore(); // dragging on files in same panel, ignore
return;
} else if (!file || file->isDir()) { // item is ".." dummy or a directory
destinationDir = item->name();
}
} else if (dragFromThisPanel) {
event->ignore(); // dragged from this panel onto an empty spot in this panel, ignore
return;
}
QUrl destination = QUrl(virtualPath());
destination.setPath(destination.path() + '/' + destinationDir);
func->files()->dropFiles(destination, event);
if(KConfigGroup(krConfig, "Look&Feel").readEntry("UnselectBeforeOperation",
_UnselectBeforeOperation)) {
KrPanel *p = dragFromThisPanel ? this : otherPanel();
p->view->saveSelection();
p->view->unselectAll();
}
}
void ListPanel::handleDrop(const QUrl &destination, QDropEvent *event)
{
func->files()->dropFiles(destination, event);
}
void ListPanel::startDragging(const QStringList& names, const QPixmap& px)
{
if (names.isEmpty()) { // avoid dragging empty urls
return;
}
QList urls = func->files()->getUrls(names);
auto *drag = new QDrag(this);
auto *mimeData = new QMimeData;
drag->setPixmap(px);
mimeData->setUrls(urls);
drag->setMimeData(mimeData);
drag->exec(Qt::MoveAction | Qt::CopyAction | Qt::LinkAction);
}
// pops a right-click menu for items
void ListPanel::popRightClickMenu(const QPoint &loc)
{
// run it, on the mouse location
int j = QFontMetrics(font()).height() * 2;
PanelContextMenu::run(QPoint(loc.x() + 5, loc.y() + j), this);
}
void ListPanel::popEmptyRightClickMenu(const QPoint &loc)
{
PanelContextMenu::run(loc, this);
}
QString ListPanel::getCurrentName() const
{
const QString name = view->getCurrentItem();
return name == ".." ? QString() : name;
}
QStringList ListPanel::getSelectedNames()
{
QStringList fileNames;
view->getSelectedItems(&fileNames);
return fileNames;
}
void ListPanel::prepareToDelete()
{
const bool skipCurrent = (view->numSelected() == 0);
view->setNameToMakeCurrent(view->firstUnmarkedBelowCurrent(skipCurrent));
}
void ListPanel::keyPressEvent(QKeyEvent *e)
{
switch (e->key()) {
case Qt::Key_Enter :
case Qt::Key_Return :
if (e->modifiers() & Qt::ControlModifier) {
if (e->modifiers() & Qt::AltModifier) {
FileItem *fileitem =
func->files()->getFileItem(view->getCurrentKrViewItem()->name());
if (fileitem && fileitem->isDir())
newTab(fileitem->getUrl(), true);
} else {
SLOTS->insertFileName((e->modifiers()&Qt::ShiftModifier)!=0);
}
} else {
e->ignore();
}
break;
case Qt::Key_Right :
case Qt::Key_Left :
if (e->modifiers() == Qt::ControlModifier) {
// user pressed CTRL+Right/Left - refresh other panel to the selected path if it's a
// directory otherwise as this one
if ((isLeft() && e->key() == Qt::Key_Right) || (!isLeft() && e->key() == Qt::Key_Left)) {
QUrl newPath;
KrViewItem *it = view->getCurrentKrViewItem();
if (it->name() == "..") {
newPath = KIO::upUrl(virtualPath());
} else {
FileItem *v = func->getFileItem(it);
// If it's a directory different from ".."
if (v && v->isDir() && v->getName() != "..") {
newPath = v->getUrl();
} else {
// If it's a supported compressed file
if (v && KRarcHandler::arcSupported(v->getMime())) {
newPath = func->browsableArchivePath(v->getUrl().fileName());
} else {
newPath = virtualPath();
}
}
}
otherPanel()->func->openUrl(newPath);
} else {
func->openUrl(otherPanel()->virtualPath());
}
return;
} else
e->ignore();
break;
case Qt::Key_Down :
if (e->modifiers() == Qt::ControlModifier) { // give the keyboard focus to the command line
if (MAIN_VIEW->cmdLine()->isVisible())
MAIN_VIEW->cmdLineFocus();
else
MAIN_VIEW->focusTerminalEmulator();
return;
} else if (e->modifiers() == (Qt::ControlModifier | Qt::ShiftModifier)) { // give the keyboard focus to TE
MAIN_VIEW->focusTerminalEmulator();
} else
e->ignore();
break;
case Qt::Key_Up :
if (e->modifiers() == Qt::ControlModifier) { // give the keyboard focus to the url navigator
editLocation();
return;
} else
e->ignore();
break;
case Qt::Key_Escape:
cancelProgress();
break;
default:
// if we got this, it means that the view is not doing
// the quick search thing, so send the characters to the commandline, if normal key
if (e->modifiers() == Qt::NoModifier)
MAIN_VIEW->cmdLine()->addText(e->text());
//e->ignore();
}
}
void ListPanel::showEvent(QShowEvent *e)
{
panelVisible();
QWidget::showEvent(e);
}
void ListPanel::hideEvent(QHideEvent *e)
{
panelHidden();
QWidget::hideEvent(e);
}
void ListPanel::panelVisible()
{
func->setPaused(false);
}
void ListPanel::panelHidden()
{
func->setPaused(true);
}
void ListPanel::slotPreviewJobStarted(KJob *job)
{
previewJob = job;
connect(job, SIGNAL(percent(KJob*,ulong)), SLOT(slotPreviewJobPercent(KJob*,ulong)));
connect(job, &KJob::result, this, &ListPanel::slotPreviewJobResult);
cancelProgressButton->setMaximumHeight(sidebarButton->height());
cancelProgressButton->show();
previewProgress->setValue(0);
previewProgress->setFormat(i18n("loading previews: %p%"));
previewProgress->setMaximumHeight(cancelProgressButton->height());
previewProgress->show();
}
void ListPanel::slotPreviewJobPercent(KJob* /*job*/, unsigned long percent)
{
previewProgress->setValue(percent);
}
void ListPanel::slotPreviewJobResult(KJob* /*job*/)
{
previewJob = nullptr;
previewProgress->hide();
if(!inlineRefreshJob)
cancelProgressButton->hide();
}
void ListPanel::slotRefreshJobStarted(KIO::Job* job)
{
// disable the parts of the panel we don't want touched
status->setEnabled(false);
urlNavigator->setEnabled(false);
cdRootButton->setEnabled(false);
cdHomeButton->setEnabled(false);
cdUpButton->setEnabled(false);
cdOtherButton->setEnabled(false);
sidebarButton->setEnabled(false);
if(sidebar)
sidebar->setEnabled(false);
bookmarksButton->setEnabled(false);
historyButton->setEnabled(false);
syncBrowseButton->setEnabled(false);
// connect to the job interface to provide in-panel refresh notification
connect(job, &KIO::Job::infoMessage, this, &ListPanel::inlineRefreshInfoMessage);
connect(job, SIGNAL(percent(KJob*,ulong)),
SLOT(inlineRefreshPercent(KJob*,ulong)));
connect(job, &KIO::Job::result, this, &ListPanel::inlineRefreshListResult);
inlineRefreshJob = job;
totals->setText(i18n(">> Reading..."));
cancelProgressButton->show();
}
void ListPanel::cancelProgress()
{
if (inlineRefreshJob) {
disconnect(inlineRefreshJob, nullptr, this, nullptr);
inlineRefreshJob->kill(KJob::EmitResult);
inlineRefreshListResult(nullptr);
}
if(previewJob) {
disconnect(previewJob, nullptr, this, nullptr);
previewJob->kill(KJob::EmitResult);
slotPreviewJobResult(nullptr);
}
}
void ListPanel::setNavigatorUrl(const QUrl &url)
{
_navigatorUrl = url;
urlNavigator->setLocationUrl(url);
}
void ListPanel::inlineRefreshPercent(KJob*, unsigned long perc)
{
QString msg = i18n(">> Reading: %1 % complete...", perc);
totals->setText(msg);
}
void ListPanel::inlineRefreshInfoMessage(KJob*, const QString &msg)
{
totals->setText(i18n(">> Reading: %1", msg));
}
void ListPanel::inlineRefreshListResult(KJob*)
{
if(inlineRefreshJob)
disconnect(inlineRefreshJob, nullptr, this, nullptr);
inlineRefreshJob = nullptr;
// reenable everything
status->setEnabled(true);
urlNavigator->setEnabled(true);
cdRootButton->setEnabled(true);
cdHomeButton->setEnabled(true);
cdUpButton->setEnabled(true);
cdOtherButton->setEnabled(true);
sidebarButton->setEnabled(true);
if(sidebar)
sidebar->setEnabled(true);
bookmarksButton->setEnabled(true);
historyButton->setEnabled(true);
syncBrowseButton->setEnabled(true);
if(!previewJob)
cancelProgressButton->hide();
}
void ListPanel::jumpBack()
{
func->openUrl(_jumpBackURL);
}
void ListPanel::setJumpBack(QUrl url)
{
_jumpBackURL = std::move(url);
}
void ListPanel::slotFilesystemError(const QString& msg)
{
slotRefreshColors();
fileSystemError->setText(i18n("Error: %1", msg));
fileSystemError->show();
}
void ListPanel::showButtonMenu(QToolButton *b)
{
if(this != ACTIVE_PANEL)
slotFocusOnMe();
if(b->isHidden())
b->menu()->exec(mapToGlobal(clientArea->pos()));
else
b->click();
}
void ListPanel::openBookmarks()
{
showButtonMenu(bookmarksButton);
}
void ListPanel::openHistory()
{
showButtonMenu(historyButton);
}
void ListPanel::openMedia()
{
showButtonMenu(mediaButton);
}
void ListPanel::rightclickMenu()
{
if (view->getCurrentKrViewItem())
popRightClickMenu(mapToGlobal(view->getCurrentKrViewItem()->itemRect().topLeft()));
}
void ListPanel::toggleSyncBrowse()
{
syncBrowseButton->toggle();
}
void ListPanel::editLocation()
{
urlNavigator->setUrlEditable(true);
urlNavigator->setFocus();
urlNavigator->editor()->lineEdit()->selectAll();
}
void ListPanel::showSearchBar()
{
searchBar->showBar(KrSearchBar::MODE_SEARCH);
}
void ListPanel::showSearchBarSelection()
{
searchBar->showBar(KrSearchBar::MODE_SELECT);
}
void ListPanel::showSearchBarFilter()
{
searchBar->showBar(KrSearchBar::MODE_FILTER);
}
void ListPanel::saveSettings(KConfigGroup cfg, bool saveHistory)
{
QUrl url = virtualPath();
url.setPassword(QString()); // make sure no password is saved
cfg.writeEntry("Url", url.toString());
cfg.writeEntry("Type", getType());
cfg.writeEntry("Properties", getProperties());
cfg.writeEntry("PinnedUrl", pinnedUrl().toString());
if(saveHistory)
func->history->save(KConfigGroup(&cfg, "History"));
view->saveSettings(KConfigGroup(&cfg, "View"));
// splitter/sidebar state
if (sidebar && !sidebar->isHidden()) {
sidebar->saveSettings(KConfigGroup(&cfg, "PanelPopup"));
cfg.writeEntry("PopupPosition", sidebarPosition());
cfg.writeEntry("SplitterSizes", sidebarSplitter->saveState());
cfg.writeEntry("PopupPage", sidebar->currentPage());
} else {
cfg.deleteEntry("PopupPosition");
cfg.deleteEntry("SplitterSizes");
cfg.deleteEntry("PopupPage");
}
}
void ListPanel::restoreSettings(KConfigGroup cfg)
{
changeType(cfg.readEntry("Type", defaultPanelType()));
view->restoreSettings(KConfigGroup(&cfg, "View"));
// "locked" property must be set after URL path is restored!
// This panel can be reused when loading a profile,
// so we reset its properties before calling openUrl().
setProperties(0);
_lastLocalPath = ROOT_DIR;
if(func->history->restore(KConfigGroup(&cfg, "History"))) {
func->refresh();
} else {
QUrl url(cfg.readEntry("Url", "invalid"));
if (!url.isValid())
url = QUrl::fromLocalFile(ROOT_DIR);
func->openUrl(url);
}
setJumpBack(func->history->currentUrl());
setProperties(cfg.readEntry("Properties", 0));
if (isPinned()) {
QUrl pinnedUrl(cfg.readEntry("PinnedUrl", "invalid"));
if (!pinnedUrl.isValid()) {
pinnedUrl = func->history->currentUrl();
}
func->openUrl(pinnedUrl);
setPinnedUrl(pinnedUrl);
}
if (cfg.hasKey("PopupPosition")) { // sidebar was visible, restore
toggleSidebar(); // create and show
sidebar->restoreSettings(KConfigGroup(&cfg, "PanelPopup"));
setSidebarPosition(cfg.readEntry("PopupPosition", 42 /* dummy */));
sidebarSplitter->restoreState(cfg.readEntry("SplitterSizes", QByteArray()));
sidebar->setCurrentPage(cfg.readEntry("PopupPage", 0));
}
}
void ListPanel::slotCurrentChanged(KrViewItem *item)
{
// update status bar
if (item)
krApp->statusBarUpdate(item->description());
// update sidebar; which panel to display on?
Sidebar *p;
if (sidebar && !sidebar->isHidden()) {
p = sidebar;
} else if(otherPanel()->gui->sidebar && !otherPanel()->gui->sidebar->isHidden()) {
p = otherPanel()->gui->sidebar;
} else {
return;
}
p->update(item ? func->files()->getFileItem(item->name()) : nullptr);
}
void ListPanel::otherPanelChanged()
{
func->syncURL = QUrl();
}
void ListPanel::getFocusCandidates(QVector &widgets)
{
if(urlNavigator->editor()->isVisible())
widgets << urlNavigator->editor();
if(view->widget()->isVisible())
widgets << view->widget();
if(sidebar && sidebar->isVisible())
widgets << sidebar;
}
void ListPanel::updateButtons()
{
backButton->setEnabled(func->history->canGoBack());
forwardButton->setEnabled(func->history->canGoForward());
historyButton->setEnabled(func->history->count() > 1);
cdRootButton->setEnabled(!virtualPath().matches(QUrl::fromLocalFile(ROOT_DIR),
QUrl::StripTrailingSlash));
cdUpButton->setEnabled(!func->files()->isRoot());
cdHomeButton->setEnabled(!func->atHome());
}
void ListPanel::newTab(KrViewItem *it)
{
if (!it)
return;
else if (it->name() == "..") {
newTab(KIO::upUrl(virtualPath()), true);
} else if (func->getFileItem(it)->isDir()) {
QUrl url = virtualPath();
url = url.adjusted(QUrl::StripTrailingSlash);
url.setPath(url.path() + '/' + (it->name()));
newTab(url, true);
}
}
void ListPanel::newTab(const QUrl &url, bool nextToThis)
{
_manager->newTab(url, nextToThis ? this : nullptr);
}
void ListPanel::slotNavigatorUrlChanged(const QUrl &url)
{
if (url == _navigatorUrl)
return; // this is the URL we just set ourself
if (!isNavigatorEditModeSet()) {
urlNavigator->setUrlEditable(false);
}
func->openUrl(KrServices::escapeFileUrl(url), QString(), true);
}
void ListPanel::resetNavigatorMode()
{
if (isNavigatorEditModeSet())
return;
// set to "navigate" mode if url wasn't changed
if (urlNavigator->uncommittedUrl().matches(virtualPath(), QUrl::StripTrailingSlash)) {
// NOTE: this also sets focus to the navigator
urlNavigator->setUrlEditable(false);
slotFocusOnMe();
}
}
int ListPanel::sidebarPosition() const
{
int pos = sidebarSplitter->orientation() == Qt::Vertical ? 1 : 0;
return pos + (qobject_cast(sidebarSplitter->widget(0)) == NULL ? 2 : 0);
}
void ListPanel::setSidebarPosition(int pos)
{
sidebarSplitter->setOrientation(pos % 2 == 0 ? Qt::Horizontal : Qt::Vertical);
if ((pos < 2) != (qobject_cast(sidebarSplitter->widget(0)) != NULL)) {
sidebarSplitter->insertWidget(0, sidebarSplitter->widget(1)); // swapping widgets in splitter
}
}
void ListPanel::connectQuickSizeCalculator(SizeCalculator *sizeCalculator)
{
connect(sizeCalculator, &SizeCalculator::started, this, [=]() {
quickSizeCalcProgress->reset();
quickSizeCalcProgress->show();
cancelQuickSizeCalcButton->show();
});
connect(cancelQuickSizeCalcButton, &QToolButton::clicked, sizeCalculator, &SizeCalculator::cancel);
connect(sizeCalculator, &SizeCalculator::progressChanged, quickSizeCalcProgress, &QProgressBar::setValue);
connect(sizeCalculator, &SizeCalculator::finished, this, [=]() {
cancelQuickSizeCalcButton->hide();
quickSizeCalcProgress->hide();
});
}