diff --git a/src/dialogs/katedialogs.cpp b/src/dialogs/katedialogs.cpp
index 4732c97e..bc36cb2d 100644
--- a/src/dialogs/katedialogs.cpp
+++ b/src/dialogs/katedialogs.cpp
@@ -1,1472 +1,1472 @@
/* This file is part of the KDE libraries
Copyright (C) 2002, 2003 Anders Lund
Copyright (C) 2003 Christoph Cullmann
Copyright (C) 2001 Joseph Wenninger
Copyright (C) 2006 Dominik Haumann
Copyright (C) 2007 Mirko Stocker
Copyright (C) 2009 Michel Ludwig
Copyright (C) 2009 Erlend Hamberg
Based on work of:
Copyright (C) 1999 Jochen Wilhelmy
This library is free software; you can redistribute it and/or
modify it under the terms of the GNU Library General Public
License version 2 as published by the Free Software Foundation.
This library 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
Library General Public License for more details.
You should have received a copy of the GNU Library General Public License
along with this library; see the file COPYING.LIB. If not, write to
the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
Boston, MA 02110-1301, USA.
*/
//BEGIN Includes
#include "katedialogs.h"
#include
#include
#include "kateautoindent.h"
#include "katebuffer.h"
#include "kateconfig.h"
#include "katedocument.h"
#include "kateglobal.h"
#include "kateschema.h"
#include "katemodeconfigpage.h"
#include "kateview.h"
#include "spellcheck/spellcheck.h"
#include "kateglobal.h"
// auto generated ui files
#include "ui_textareaappearanceconfigwidget.h"
#include "ui_bordersappearanceconfigwidget.h"
#include "ui_navigationconfigwidget.h"
#include "ui_editconfigwidget.h"
#include "ui_indentationconfigwidget.h"
#include "ui_completionconfigtab.h"
#include "ui_opensaveconfigwidget.h"
#include "ui_opensaveconfigadvwidget.h"
#include "ui_spellcheckconfigwidget.h"
#include
#include
#include
#include
#include
#include
#include "katepartdebug.h"
#include "kateabstractinputmodefactory.h"
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
// trailing slash is important
#define HLDOWNLOADPATH QStringLiteral("http://kate.kde.org/syntax/")
//END
//BEGIN KateIndentConfigTab
KateIndentConfigTab::KateIndentConfigTab(QWidget *parent)
: KateConfigPage(parent)
{
// This will let us have more separation between this page and
// the QTabWidget edge (ereslibre)
QVBoxLayout *layout = new QVBoxLayout;
QWidget *newWidget = new QWidget(this);
ui = new Ui::IndentationConfigWidget();
ui->setupUi(newWidget);
ui->cmbMode->addItems(KateAutoIndent::listModes());
ui->label->setTextInteractionFlags(Qt::LinksAccessibleByMouse | Qt::LinksAccessibleByKeyboard);
connect(ui->label, SIGNAL(linkActivated(QString)), this, SLOT(showWhatsThis(QString)));
// What's This? help can be found in the ui file
reload();
//
// after initial reload, connect the stuff for the changed () signal
//
connect(ui->cmbMode, SIGNAL(activated(int)), this, SLOT(slotChanged()));
connect(ui->rbIndentWithTabs, SIGNAL(toggled(bool)), this, SLOT(slotChanged()));
connect(ui->rbIndentWithSpaces, SIGNAL(toggled(bool)), this, SLOT(slotChanged()));
connect(ui->rbIndentMixed, SIGNAL(toggled(bool)), this, SLOT(slotChanged()));
connect(ui->rbIndentWithTabs, SIGNAL(toggled(bool)), ui->sbIndentWidth, SLOT(setDisabled(bool)));
connect(ui->chkKeepExtraSpaces, SIGNAL(toggled(bool)), this, SLOT(slotChanged()));
connect(ui->chkIndentPaste, SIGNAL(toggled(bool)), this, SLOT(slotChanged()));
connect(ui->chkBackspaceUnindents, SIGNAL(toggled(bool)), this, SLOT(slotChanged()));
connect(ui->sbTabWidth, SIGNAL(valueChanged(int)), this, SLOT(slotChanged()));
connect(ui->sbIndentWidth, SIGNAL(valueChanged(int)), this, SLOT(slotChanged()));
connect(ui->rbTabAdvances, SIGNAL(toggled(bool)), this, SLOT(slotChanged()));
connect(ui->rbTabIndents, SIGNAL(toggled(bool)), this, SLOT(slotChanged()));
connect(ui->rbTabSmart, SIGNAL(toggled(bool)), this, SLOT(slotChanged()));
layout->addWidget(newWidget);
setLayout(layout);
}
KateIndentConfigTab::~KateIndentConfigTab()
{
delete ui;
}
void KateIndentConfigTab::slotChanged()
{
if (ui->rbIndentWithTabs->isChecked()) {
ui->sbIndentWidth->setValue(ui->sbTabWidth->value());
}
KateConfigPage::slotChanged();
}
void KateIndentConfigTab::showWhatsThis(const QString &text)
{
QWhatsThis::showText(QCursor::pos(), text);
}
void KateIndentConfigTab::apply()
{
// nothing changed, no need to apply stuff
if (!hasChanged()) {
return;
}
m_changed = false;
KateDocumentConfig::global()->configStart();
KateDocumentConfig::global()->setKeepExtraSpaces(ui->chkKeepExtraSpaces->isChecked());
KateDocumentConfig::global()->setBackspaceIndents(ui->chkBackspaceUnindents->isChecked());
KateDocumentConfig::global()->setIndentPastedText(ui->chkIndentPaste->isChecked());
KateDocumentConfig::global()->setIndentationWidth(ui->sbIndentWidth->value());
KateDocumentConfig::global()->setIndentationMode(KateAutoIndent::modeName(ui->cmbMode->currentIndex()));
KateDocumentConfig::global()->setTabWidth(ui->sbTabWidth->value());
KateDocumentConfig::global()->setReplaceTabsDyn(ui->rbIndentWithSpaces->isChecked());
if (ui->rbTabAdvances->isChecked()) {
KateDocumentConfig::global()->setTabHandling(KateDocumentConfig::tabInsertsTab);
} else if (ui->rbTabIndents->isChecked()) {
KateDocumentConfig::global()->setTabHandling(KateDocumentConfig::tabIndents);
} else {
KateDocumentConfig::global()->setTabHandling(KateDocumentConfig::tabSmart);
}
KateDocumentConfig::global()->configEnd();
}
void KateIndentConfigTab::reload()
{
ui->sbTabWidth->setSuffix(ki18np(" character", " characters"));
ui->sbTabWidth->setValue(KateDocumentConfig::global()->tabWidth());
ui->sbIndentWidth->setSuffix(ki18np(" character", " characters"));
ui->sbIndentWidth->setValue(KateDocumentConfig::global()->indentationWidth());
ui->chkKeepExtraSpaces->setChecked(KateDocumentConfig::global()->keepExtraSpaces());
ui->chkIndentPaste->setChecked(KateDocumentConfig::global()->indentPastedText());
ui->chkBackspaceUnindents->setChecked(KateDocumentConfig::global()->backspaceIndents());
ui->rbTabAdvances->setChecked(KateDocumentConfig::global()->tabHandling() == KateDocumentConfig::tabInsertsTab);
ui->rbTabIndents->setChecked(KateDocumentConfig::global()->tabHandling() == KateDocumentConfig::tabIndents);
ui->rbTabSmart->setChecked(KateDocumentConfig::global()->tabHandling() == KateDocumentConfig::tabSmart);
ui->cmbMode->setCurrentIndex(KateAutoIndent::modeNumber(KateDocumentConfig::global()->indentationMode()));
if (KateDocumentConfig::global()->replaceTabsDyn()) {
ui->rbIndentWithSpaces->setChecked(true);
} else {
if (KateDocumentConfig::global()->indentationWidth() == KateDocumentConfig::global()->tabWidth()) {
ui->rbIndentWithTabs->setChecked(true);
} else {
ui->rbIndentMixed->setChecked(true);
}
}
ui->sbIndentWidth->setEnabled(!ui->rbIndentWithTabs->isChecked());
}
QString KateIndentConfigTab::name() const
{
return i18n("Indentation");
}
//END KateIndentConfigTab
//BEGIN KateCompletionConfigTab
KateCompletionConfigTab::KateCompletionConfigTab(QWidget *parent)
: KateConfigPage(parent)
{
// This will let us have more separation between this page and
// the QTabWidget edge (ereslibre)
QVBoxLayout *layout = new QVBoxLayout;
QWidget *newWidget = new QWidget(this);
ui = new Ui::CompletionConfigTab();
ui->setupUi(newWidget);
// What's This? help can be found in the ui file
reload();
//
// after initial reload, connect the stuff for the changed () signal
//
connect(ui->chkAutoCompletionEnabled, SIGNAL(toggled(bool)), this, SLOT(slotChanged()));
connect(ui->gbWordCompletion, SIGNAL(toggled(bool)), this, SLOT(slotChanged()));
connect(ui->gbKeywordCompletion, SIGNAL(toggled(bool)), this, SLOT(slotChanged()));
connect(ui->minimalWordLength, SIGNAL(valueChanged(int)), this, SLOT(slotChanged()));
connect(ui->removeTail, SIGNAL(toggled(bool)), this, SLOT(slotChanged()));
layout->addWidget(newWidget);
setLayout(layout);
}
KateCompletionConfigTab::~KateCompletionConfigTab()
{
delete ui;
}
void KateCompletionConfigTab::showWhatsThis(const QString &text)
{
QWhatsThis::showText(QCursor::pos(), text);
}
void KateCompletionConfigTab::apply()
{
// nothing changed, no need to apply stuff
if (!hasChanged()) {
return;
}
m_changed = false;
KateViewConfig::global()->configStart();
KateViewConfig::global()->setAutomaticCompletionInvocation(ui->chkAutoCompletionEnabled->isChecked());
KateViewConfig::global()->setWordCompletion(ui->gbWordCompletion->isChecked());
KateViewConfig::global()->setWordCompletionMinimalWordLength(ui->minimalWordLength->value());
KateViewConfig::global()->setWordCompletionRemoveTail(ui->removeTail->isChecked());
KateViewConfig::global()->setKeywordCompletion(ui->gbKeywordCompletion->isChecked());
KateViewConfig::global()->configEnd();
}
void KateCompletionConfigTab::reload()
{
ui->chkAutoCompletionEnabled->setChecked(KateViewConfig::global()->automaticCompletionInvocation());
ui->gbWordCompletion->setChecked(KateViewConfig::global()->wordCompletion());
ui->minimalWordLength->setValue(KateViewConfig::global()->wordCompletionMinimalWordLength());
ui->gbKeywordCompletion->setChecked(KateViewConfig::global()->keywordCompletion());
ui->removeTail->setChecked(KateViewConfig::global()->wordCompletionRemoveTail());
}
QString KateCompletionConfigTab::name() const
{
return i18n("Auto Completion");
}
//END KateCompletionConfigTab
//BEGIN KateSpellCheckConfigTab
KateSpellCheckConfigTab::KateSpellCheckConfigTab(QWidget *parent)
: KateConfigPage(parent)
{
// This will let us have more separation between this page and
// the QTabWidget edge (ereslibre)
QVBoxLayout *layout = new QVBoxLayout;
QWidget *newWidget = new QWidget(this);
ui = new Ui::SpellCheckConfigWidget();
ui->setupUi(newWidget);
// What's This? help can be found in the ui file
reload();
//
// after initial reload, connect the stuff for the changed () signal
m_sonnetConfigWidget = new Sonnet::ConfigWidget(this);
connect(m_sonnetConfigWidget, SIGNAL(configChanged()), this, SLOT(slotChanged()));
layout->addWidget(m_sonnetConfigWidget);
layout->addWidget(newWidget);
setLayout(layout);
}
KateSpellCheckConfigTab::~KateSpellCheckConfigTab()
{
delete ui;
}
void KateSpellCheckConfigTab::showWhatsThis(const QString &text)
{
QWhatsThis::showText(QCursor::pos(), text);
}
void KateSpellCheckConfigTab::apply()
{
if (!hasChanged()) {
// nothing changed, no need to apply stuff
return;
}
m_changed = false;
KateDocumentConfig::global()->configStart();
m_sonnetConfigWidget->save();
KateDocumentConfig::global()->configEnd();
foreach (KTextEditor::DocumentPrivate *doc, KTextEditor::EditorPrivate::self()->kateDocuments()) {
doc->refreshOnTheFlyCheck();
}
}
void KateSpellCheckConfigTab::reload()
{
// does nothing
}
QString KateSpellCheckConfigTab::name() const
{
return i18n("Spellcheck");
}
//END KateSpellCheckConfigTab
//BEGIN KateNavigationConfigTab
KateNavigationConfigTab::KateNavigationConfigTab(QWidget *parent)
: KateConfigPage(parent)
{
// This will let us having more separation between this page and
// the QTabWidget edge (ereslibre)
QVBoxLayout *layout = new QVBoxLayout;
QWidget *newWidget = new QWidget(this);
ui = new Ui::NavigationConfigWidget();
ui->setupUi(newWidget);
// What's This? Help is in the ui-files
reload();
//
// after initial reload, connect the stuff for the changed () signal
//
connect(ui->cbTextSelectionMode, SIGNAL(currentIndexChanged(int)), this, SLOT(slotChanged()));
connect(ui->chkSmartHome, SIGNAL(toggled(bool)), this, SLOT(slotChanged()));
connect(ui->chkPagingMovesCursor, SIGNAL(toggled(bool)), this, SLOT(slotChanged()));
connect(ui->sbAutoCenterCursor, SIGNAL(valueChanged(int)), this, SLOT(slotChanged()));
connect(ui->chkScrollPastEnd, SIGNAL(toggled(bool)), this, SLOT(slotChanged()));
connect(ui->chkBackspaceRemoveComposed, SIGNAL(toggled(bool)), this, SLOT(slotChanged()));
layout->addWidget(newWidget);
setLayout(layout);
}
KateNavigationConfigTab::~KateNavigationConfigTab()
{
delete ui;
}
void KateNavigationConfigTab::apply()
{
// nothing changed, no need to apply stuff
if (!hasChanged()) {
return;
}
m_changed = false;
KateViewConfig::global()->configStart();
KateDocumentConfig::global()->configStart();
KateDocumentConfig::global()->setSmartHome(ui->chkSmartHome->isChecked());
KateViewConfig::global()->setAutoCenterLines(qMax(0, ui->sbAutoCenterCursor->value()));
KateDocumentConfig::global()->setPageUpDownMovesCursor(ui->chkPagingMovesCursor->isChecked());
KateViewConfig::global()->setPersistentSelection(ui->cbTextSelectionMode->currentIndex() == 1);
KateViewConfig::global()->setScrollPastEnd(ui->chkScrollPastEnd->isChecked());
KateViewConfig::global()->setBackspaceRemoveComposed(ui->chkBackspaceRemoveComposed->isChecked());
KateDocumentConfig::global()->configEnd();
KateViewConfig::global()->configEnd();
}
void KateNavigationConfigTab::reload()
{
ui->cbTextSelectionMode->setCurrentIndex(KateViewConfig::global()->persistentSelection() ? 1 : 0);
ui->chkSmartHome->setChecked(KateDocumentConfig::global()->smartHome());
ui->chkPagingMovesCursor->setChecked(KateDocumentConfig::global()->pageUpDownMovesCursor());
ui->sbAutoCenterCursor->setValue(KateViewConfig::global()->autoCenterLines());
ui->chkScrollPastEnd->setChecked(KateViewConfig::global()->scrollPastEnd());
ui->chkBackspaceRemoveComposed->setChecked(KateViewConfig::global()->backspaceRemoveComposed());
}
QString KateNavigationConfigTab::name() const
{
return i18n("Text Navigation");
}
//END KateNavigationConfigTab
//BEGIN KateEditGeneralConfigTab
KateEditGeneralConfigTab::KateEditGeneralConfigTab(QWidget *parent)
: KateConfigPage(parent)
{
QVBoxLayout *layout = new QVBoxLayout;
QWidget *newWidget = new QWidget(this);
ui = new Ui::EditConfigWidget();
ui->setupUi(newWidget);
QList inputModes = KTextEditor::EditorPrivate::self()->inputModeFactories();
Q_FOREACH(KateAbstractInputModeFactory *fact, inputModes) {
ui->cmbInputMode->addItem(fact->name(), static_cast(fact->inputMode()));
}
reload();
connect(ui->chkStaticWordWrap, SIGNAL(toggled(bool)), this, SLOT(slotChanged()));
connect(ui->chkShowStaticWordWrapMarker, SIGNAL(toggled(bool)), this, SLOT(slotChanged()));
connect(ui->sbWordWrap, SIGNAL(valueChanged(int)), this, SLOT(slotChanged()));
connect(ui->chkAutoBrackets, SIGNAL(toggled(bool)), this, SLOT(slotChanged()));
connect(ui->chkSmartCopyCut, SIGNAL(toggled(bool)), this, SLOT(slotChanged()));
connect(ui->cmbInputMode, SIGNAL(currentIndexChanged(int)), this, SLOT(slotChanged()));
// "What's this?" help is in the ui-file
layout->addWidget(newWidget);
setLayout(layout);
}
KateEditGeneralConfigTab::~KateEditGeneralConfigTab()
{
delete ui;
}
void KateEditGeneralConfigTab::apply()
{
// nothing changed, no need to apply stuff
if (!hasChanged()) {
return;
}
m_changed = false;
KateViewConfig::global()->configStart();
KateDocumentConfig::global()->configStart();
KateDocumentConfig::global()->setWordWrapAt(ui->sbWordWrap->value());
KateDocumentConfig::global()->setWordWrap(ui->chkStaticWordWrap->isChecked());
KateRendererConfig::global()->setWordWrapMarker(ui->chkShowStaticWordWrapMarker->isChecked());
KateViewConfig::global()->setAutoBrackets(ui->chkAutoBrackets->isChecked());
KateViewConfig::global()->setSmartCopyCut(ui->chkSmartCopyCut->isChecked());
KateViewConfig::global()->setInputModeRaw(ui->cmbInputMode->currentData().toInt());
KateDocumentConfig::global()->configEnd();
KateViewConfig::global()->configEnd();
}
void KateEditGeneralConfigTab::reload()
{
ui->chkStaticWordWrap->setChecked(KateDocumentConfig::global()->wordWrap());
ui->chkShowStaticWordWrapMarker->setChecked(KateRendererConfig::global()->wordWrapMarker());
ui->sbWordWrap->setSuffix(ki18ncp("Wrap words at (value is at 20 or larger)", " character", " characters"));
ui->sbWordWrap->setValue(KateDocumentConfig::global()->wordWrapAt());
ui->chkAutoBrackets->setChecked(KateViewConfig::global()->autoBrackets());
ui->chkSmartCopyCut->setChecked(KateViewConfig::global()->smartCopyCut());
const int id = static_cast(KateViewConfig::global()->inputMode());
ui->cmbInputMode->setCurrentIndex(ui->cmbInputMode->findData(id));
}
QString KateEditGeneralConfigTab::name() const
{
return i18n("General");
}
//END KateEditGeneralConfigTab
//BEGIN KateEditConfigTab
KateEditConfigTab::KateEditConfigTab(QWidget *parent)
: KateConfigPage(parent)
, editConfigTab(new KateEditGeneralConfigTab(this))
, navigationConfigTab(new KateNavigationConfigTab(this))
, indentConfigTab(new KateIndentConfigTab(this))
, completionConfigTab(new KateCompletionConfigTab(this))
, spellCheckConfigTab(new KateSpellCheckConfigTab(this))
{
QVBoxLayout *layout = new QVBoxLayout;
layout->setMargin(0);
QTabWidget *tabWidget = new QTabWidget(this);
// add all tabs
tabWidget->insertTab(0, editConfigTab, editConfigTab->name());
tabWidget->insertTab(1, navigationConfigTab, navigationConfigTab->name());
tabWidget->insertTab(2, indentConfigTab, indentConfigTab->name());
tabWidget->insertTab(3, completionConfigTab, completionConfigTab->name());
tabWidget->insertTab(4, spellCheckConfigTab, spellCheckConfigTab->name());
connect(editConfigTab, SIGNAL(changed()), this, SLOT(slotChanged()));
connect(navigationConfigTab, SIGNAL(changed()), this, SLOT(slotChanged()));
connect(indentConfigTab, SIGNAL(changed()), this, SLOT(slotChanged()));
connect(completionConfigTab, SIGNAL(changed()), this, SLOT(slotChanged()));
connect(spellCheckConfigTab, SIGNAL(changed()), this, SLOT(slotChanged()));
int i = tabWidget->count();
Q_FOREACH(KateAbstractInputModeFactory *factory, KTextEditor::EditorPrivate::self()->inputModeFactories()) {
KateConfigPage *tab = factory->createConfigPage(this);
if (tab) {
m_inputModeConfigTabs << tab;
tabWidget->insertTab(i, tab, tab->name());
connect(tab, SIGNAL(changed()), this, SLOT(slotChanged()));
i++;
}
}
layout->addWidget(tabWidget);
setLayout(layout);
}
KateEditConfigTab::~KateEditConfigTab()
{
qDeleteAll(m_inputModeConfigTabs);
}
void KateEditConfigTab::apply()
{
// try to update the rest of tabs
editConfigTab->apply();
navigationConfigTab->apply();
indentConfigTab->apply();
completionConfigTab->apply();
spellCheckConfigTab->apply();
Q_FOREACH(KateConfigPage *tab, m_inputModeConfigTabs) {
tab->apply();
}
}
void KateEditConfigTab::reload()
{
editConfigTab->reload();
navigationConfigTab->reload();
indentConfigTab->reload();
completionConfigTab->reload();
spellCheckConfigTab->reload();
Q_FOREACH(KateConfigPage *tab, m_inputModeConfigTabs) {
tab->reload();
}
}
void KateEditConfigTab::reset()
{
editConfigTab->reset();
navigationConfigTab->reset();
indentConfigTab->reset();
completionConfigTab->reset();
spellCheckConfigTab->reset();
Q_FOREACH(KateConfigPage *tab, m_inputModeConfigTabs) {
tab->reset();
}
}
void KateEditConfigTab::defaults()
{
editConfigTab->defaults();
navigationConfigTab->defaults();
indentConfigTab->defaults();
completionConfigTab->defaults();
spellCheckConfigTab->defaults();
Q_FOREACH(KateConfigPage *tab, m_inputModeConfigTabs) {
tab->defaults();
}
}
QString KateEditConfigTab::name() const
{
return i18n("Editing");
}
QString KateEditConfigTab::fullName() const
{
return i18n("Editing Options");
}
QIcon KateEditConfigTab::icon() const
{
return QIcon::fromTheme(QStringLiteral("accessories-text-editor"));
}
//END KateEditConfigTab
//BEGIN KateViewDefaultsConfig
KateViewDefaultsConfig::KateViewDefaultsConfig(QWidget *parent)
: KateConfigPage(parent)
, textareaUi(new Ui::TextareaAppearanceConfigWidget())
, bordersUi(new Ui::BordersAppearanceConfigWidget())
{
QLayout *layout = new QVBoxLayout(this);
QTabWidget *tabWidget = new QTabWidget(this);
layout->addWidget(tabWidget);
layout->setMargin(0);
QWidget *textareaTab = new QWidget(tabWidget);
textareaUi->setupUi(textareaTab);
tabWidget->addTab(textareaTab, i18n("General"));
QWidget *bordersTab = new QWidget(tabWidget);
bordersUi->setupUi(bordersTab);
tabWidget->addTab(bordersTab, i18n("Borders"));
textareaUi->cmbDynamicWordWrapIndicator->addItem(i18n("Off"));
textareaUi->cmbDynamicWordWrapIndicator->addItem(i18n("Follow Line Numbers"));
textareaUi->cmbDynamicWordWrapIndicator->addItem(i18n("Always On"));
// What's This? help is in the ui-file
reload();
//
// after initial reload, connect the stuff for the changed () signal
//
connect(textareaUi->gbWordWrap, SIGNAL(toggled(bool)), this, SLOT(slotChanged()));
connect(textareaUi->cmbDynamicWordWrapIndicator, SIGNAL(activated(int)), this, SLOT(slotChanged()));
connect(textareaUi->sbDynamicWordWrapDepth, SIGNAL(valueChanged(int)), this, SLOT(slotChanged()));
connect(textareaUi->chkShowTabs, SIGNAL(toggled(bool)), this, SLOT(slotChanged()));
connect(textareaUi->chkShowSpaces, SIGNAL(toggled(bool)), this, SLOT(slotChanged()));
connect(textareaUi->chkShowIndentationLines, SIGNAL(toggled(bool)), this, SLOT(slotChanged()));
connect(textareaUi->sliSetMarkerSize, SIGNAL(valueChanged(int)), this, SLOT(slotChanged()));
connect(textareaUi->chkShowWholeBracketExpression, SIGNAL(toggled(bool)), this, SLOT(slotChanged()));
connect(textareaUi->chkAnimateBracketMatching, SIGNAL(toggled(bool)), this, SLOT(slotChanged()));
connect(textareaUi->chkFoldFirstLine, SIGNAL(toggled(bool)), this, SLOT(slotChanged()));
connect(textareaUi->chkShowWordCount, SIGNAL(toggled(bool)), this, SLOT(slotChanged()));
connect(textareaUi->chkShowLinesCount, SIGNAL(toggled(bool)), this, SLOT(slotChanged()));
connect(bordersUi->chkIconBorder, SIGNAL(toggled(bool)), this, SLOT(slotChanged()));
connect(bordersUi->chkScrollbarMarks, SIGNAL(toggled(bool)), this, SLOT(slotChanged()));
connect(bordersUi->chkScrollbarPreview, SIGNAL(toggled(bool)), this, SLOT(slotChanged()));
connect(bordersUi->chkScrollbarMiniMap, SIGNAL(toggled(bool)), this, SLOT(slotChanged()));
connect(bordersUi->chkScrollbarMiniMapAll, SIGNAL(toggled(bool)), this, SLOT(slotChanged()));
bordersUi->chkScrollbarMiniMapAll->hide(); // this is temporary until the feature is done
connect(bordersUi->spBoxMiniMapWidth, SIGNAL(valueChanged(int)), this, SLOT(slotChanged()));
connect(bordersUi->chkLineNumbers, SIGNAL(toggled(bool)), this, SLOT(slotChanged()));
connect(bordersUi->chkShowLineModification, SIGNAL(toggled(bool)), this, SLOT(slotChanged()));
connect(bordersUi->chkShowFoldingMarkers, SIGNAL(toggled(bool)), this, SLOT(slotChanged()));
connect(bordersUi->chkShowFoldingPreview, SIGNAL(toggled(bool)), this, SLOT(slotChanged()));
connect(bordersUi->rbSortBookmarksByPosition, SIGNAL(toggled(bool)), this, SLOT(slotChanged()));
connect(bordersUi->rbSortBookmarksByCreation, SIGNAL(toggled(bool)), this, SLOT(slotChanged()));
connect(bordersUi->cmbShowScrollbars, SIGNAL(activated(int)), this, SLOT(slotChanged()));
}
KateViewDefaultsConfig::~KateViewDefaultsConfig()
{
delete bordersUi;
delete textareaUi;
}
void KateViewDefaultsConfig::apply()
{
// nothing changed, no need to apply stuff
if (!hasChanged()) {
return;
}
m_changed = false;
KateViewConfig::global()->configStart();
KateRendererConfig::global()->configStart();
KateViewConfig::global()->setDynWordWrap(textareaUi->gbWordWrap->isChecked());
KateViewConfig::global()->setDynWordWrapIndicators(textareaUi->cmbDynamicWordWrapIndicator->currentIndex());
KateViewConfig::global()->setDynWordWrapAlignIndent(textareaUi->sbDynamicWordWrapDepth->value());
KateDocumentConfig::global()->setShowTabs(textareaUi->chkShowTabs->isChecked());
KateDocumentConfig::global()->setShowSpaces(textareaUi->chkShowSpaces->isChecked());
KateDocumentConfig::global()->setMarkerSize(textareaUi->sliSetMarkerSize->value());
KateViewConfig::global()->setLineNumbers(bordersUi->chkLineNumbers->isChecked());
KateViewConfig::global()->setIconBar(bordersUi->chkIconBorder->isChecked());
KateViewConfig::global()->setScrollBarMarks(bordersUi->chkScrollbarMarks->isChecked());
KateViewConfig::global()->setScrollBarPreview(bordersUi->chkScrollbarPreview->isChecked());
KateViewConfig::global()->setScrollBarMiniMap(bordersUi->chkScrollbarMiniMap->isChecked());
KateViewConfig::global()->setScrollBarMiniMapAll(bordersUi->chkScrollbarMiniMapAll->isChecked());
KateViewConfig::global()->setScrollBarMiniMapWidth(bordersUi->spBoxMiniMapWidth->value());
KateViewConfig::global()->setFoldingBar(bordersUi->chkShowFoldingMarkers->isChecked());
KateViewConfig::global()->setFoldingPreview(bordersUi->chkShowFoldingPreview->isChecked());
KateViewConfig::global()->setLineModification(bordersUi->chkShowLineModification->isChecked());
KateViewConfig::global()->setShowScrollbars(bordersUi->cmbShowScrollbars->currentIndex());
KateViewConfig::global()->setBookmarkSort(bordersUi->rbSortBookmarksByPosition->isChecked() ? 0 : 1);
KateRendererConfig::global()->setShowIndentationLines(textareaUi->chkShowIndentationLines->isChecked());
KateRendererConfig::global()->setShowWholeBracketExpression(textareaUi->chkShowWholeBracketExpression->isChecked());
KateRendererConfig::global()->setAnimateBracketMatching(textareaUi->chkAnimateBracketMatching->isChecked());
KateViewConfig::global()->setFoldFirstLine(textareaUi->chkFoldFirstLine->isChecked());
KateViewConfig::global()->setShowWordCount(textareaUi->chkShowWordCount->isChecked());
KateViewConfig::global()->setShowLinesCount(textareaUi->chkShowLinesCount->isChecked());
KateRendererConfig::global()->configEnd();
KateViewConfig::global()->configEnd();
}
void KateViewDefaultsConfig::reload()
{
textareaUi->gbWordWrap->setChecked(KateViewConfig::global()->dynWordWrap());
textareaUi->cmbDynamicWordWrapIndicator->setCurrentIndex(KateViewConfig::global()->dynWordWrapIndicators());
textareaUi->sbDynamicWordWrapDepth->setValue(KateViewConfig::global()->dynWordWrapAlignIndent());
textareaUi->chkShowTabs->setChecked(KateDocumentConfig::global()->showTabs());
textareaUi->chkShowSpaces->setChecked(KateDocumentConfig::global()->showSpaces());
textareaUi->sliSetMarkerSize->setValue(KateDocumentConfig::global()->markerSize());
bordersUi->chkLineNumbers->setChecked(KateViewConfig::global()->lineNumbers());
bordersUi->chkIconBorder->setChecked(KateViewConfig::global()->iconBar());
bordersUi->chkScrollbarMarks->setChecked(KateViewConfig::global()->scrollBarMarks());
bordersUi->chkScrollbarPreview->setChecked(KateViewConfig::global()->scrollBarPreview());
bordersUi->chkScrollbarMiniMap->setChecked(KateViewConfig::global()->scrollBarMiniMap());
bordersUi->chkScrollbarMiniMapAll->setChecked(KateViewConfig::global()->scrollBarMiniMapAll());
bordersUi->spBoxMiniMapWidth->setValue(KateViewConfig::global()->scrollBarMiniMapWidth());
bordersUi->chkShowFoldingMarkers->setChecked(KateViewConfig::global()->foldingBar());
bordersUi->chkShowFoldingPreview->setChecked(KateViewConfig::global()->foldingPreview());
bordersUi->chkShowLineModification->setChecked(KateViewConfig::global()->lineModification());
bordersUi->rbSortBookmarksByPosition->setChecked(KateViewConfig::global()->bookmarkSort() == 0);
bordersUi->rbSortBookmarksByCreation->setChecked(KateViewConfig::global()->bookmarkSort() == 1);
bordersUi->cmbShowScrollbars->setCurrentIndex(KateViewConfig::global()->showScrollbars());
textareaUi->chkShowIndentationLines->setChecked(KateRendererConfig::global()->showIndentationLines());
textareaUi->chkShowWholeBracketExpression->setChecked(KateRendererConfig::global()->showWholeBracketExpression());
textareaUi->chkAnimateBracketMatching->setChecked(KateRendererConfig::global()->animateBracketMatching());
textareaUi->chkFoldFirstLine->setChecked(KateViewConfig::global()->foldFirstLine());
textareaUi->chkShowWordCount->setChecked(KateViewConfig::global()->showWordCount());
textareaUi->chkShowLinesCount->setChecked(KateViewConfig::global()->showLinesCount());
}
void KateViewDefaultsConfig::reset()
{
;
}
void KateViewDefaultsConfig::defaults()
{
;
}
QString KateViewDefaultsConfig::name() const
{
return i18n("Appearance");
}
QString KateViewDefaultsConfig::fullName() const
{
return i18n("Appearance");
}
QIcon KateViewDefaultsConfig::icon() const
{
return QIcon::fromTheme(QStringLiteral("preferences-desktop-theme"));
}
//END KateViewDefaultsConfig
//BEGIN KateSaveConfigTab
KateSaveConfigTab::KateSaveConfigTab(QWidget *parent)
: KateConfigPage(parent)
, modeConfigPage(new ModeConfigPage(this))
{
// FIXME: Is really needed to move all this code below to another class,
// since it is another tab itself on the config dialog. This means we should
// initialize, add and work with as we do with modeConfigPage (ereslibre)
QVBoxLayout *layout = new QVBoxLayout;
layout->setMargin(0);
QTabWidget *tabWidget = new QTabWidget(this);
QWidget *tmpWidget = new QWidget(tabWidget);
QVBoxLayout *internalLayout = new QVBoxLayout;
QWidget *newWidget = new QWidget(tabWidget);
ui = new Ui::OpenSaveConfigWidget();
ui->setupUi(newWidget);
QWidget *tmpWidget2 = new QWidget(tabWidget);
QVBoxLayout *internalLayout2 = new QVBoxLayout;
QWidget *newWidget2 = new QWidget(tabWidget);
uiadv = new Ui::OpenSaveConfigAdvWidget();
uiadv->setupUi(newWidget2);
// What's this help is added in ui/opensaveconfigwidget.ui
reload();
//
// after initial reload, connect the stuff for the changed () signal
//
connect(ui->cmbEncoding, SIGNAL(activated(int)), this, SLOT(slotChanged()));
connect(ui->cmbEncodingDetection, SIGNAL(activated(int)), this, SLOT(slotChanged()));
connect(ui->cmbEncodingFallback, SIGNAL(activated(int)), this, SLOT(slotChanged()));
connect(ui->cmbEOL, SIGNAL(activated(int)), this, SLOT(slotChanged()));
connect(ui->chkDetectEOL, SIGNAL(toggled(bool)), this, SLOT(slotChanged()));
connect(ui->chkEnableBOM, SIGNAL(toggled(bool)), this, SLOT(slotChanged()));
connect(ui->lineLengthLimit, SIGNAL(valueChanged(int)), this, SLOT(slotChanged()));
connect(ui->cbRemoveTrailingSpaces, SIGNAL(currentIndexChanged(int)), this, SLOT(slotChanged()));
connect(ui->chkNewLineAtEof, SIGNAL(toggled(bool)), this, SLOT(slotChanged()));
connect(uiadv->chkBackupLocalFiles, SIGNAL(toggled(bool)), this, SLOT(slotChanged()));
connect(uiadv->chkBackupRemoteFiles, SIGNAL(toggled(bool)), this, SLOT(slotChanged()));
connect(uiadv->edtBackupPrefix, SIGNAL(textChanged(QString)), this, SLOT(slotChanged()));
connect(uiadv->edtBackupSuffix, SIGNAL(textChanged(QString)), this, SLOT(slotChanged()));
connect(uiadv->cmbSwapFileMode, SIGNAL(currentIndexChanged(int)), this, SLOT(slotChanged()));
connect(uiadv->cmbSwapFileMode, SIGNAL(currentIndexChanged(int)), this, SLOT(swapFileModeChanged(int)));
connect(uiadv->kurlSwapDirectory, SIGNAL(textChanged(QString)), this, SLOT(slotChanged()));
connect(uiadv->spbSwapFileSync, SIGNAL(valueChanged(int)), this, SLOT(slotChanged()));
internalLayout->addWidget(newWidget);
tmpWidget->setLayout(internalLayout);
internalLayout2->addWidget(newWidget2);
tmpWidget2->setLayout(internalLayout2);
// add all tabs
tabWidget->insertTab(0, tmpWidget, i18n("General"));
tabWidget->insertTab(1, tmpWidget2, i18n("Advanced"));
tabWidget->insertTab(2, modeConfigPage, modeConfigPage->name());
connect(modeConfigPage, SIGNAL(changed()), this, SLOT(slotChanged()));
layout->addWidget(tabWidget);
setLayout(layout);
}
KateSaveConfigTab::~KateSaveConfigTab()
{
delete ui;
}
void KateSaveConfigTab::swapFileModeChanged(int idx)
{
const KateDocumentConfig::SwapFileMode mode = static_cast(idx);
switch (mode) {
case KateDocumentConfig::DisableSwapFile:
uiadv->lblSwapDirectory->setEnabled(false);
uiadv->kurlSwapDirectory->setEnabled(false);
uiadv->lblSwapFileSync->setEnabled(false);
uiadv->spbSwapFileSync->setEnabled(false);
break;
case KateDocumentConfig::EnableSwapFile:
uiadv->lblSwapDirectory->setEnabled(false);
uiadv->kurlSwapDirectory->setEnabled(false);
uiadv->lblSwapFileSync->setEnabled(true);
uiadv->spbSwapFileSync->setEnabled(true);
break;
case KateDocumentConfig::SwapFilePresetDirectory:
uiadv->lblSwapDirectory->setEnabled(true);
uiadv->kurlSwapDirectory->setEnabled(true);
uiadv->lblSwapFileSync->setEnabled(true);
uiadv->spbSwapFileSync->setEnabled(true);
break;
}
}
void KateSaveConfigTab::apply()
{
modeConfigPage->apply();
// nothing changed, no need to apply stuff
if (!hasChanged()) {
return;
}
m_changed = false;
KateGlobalConfig::global()->configStart();
KateDocumentConfig::global()->configStart();
if (uiadv->edtBackupSuffix->text().isEmpty() && uiadv->edtBackupPrefix->text().isEmpty()) {
KMessageBox::information(
this,
i18n("You did not provide a backup suffix or prefix. Using default suffix: '~'"),
i18n("No Backup Suffix or Prefix")
);
uiadv->edtBackupSuffix->setText(QStringLiteral("~"));
}
uint f(0);
if (uiadv->chkBackupLocalFiles->isChecked()) {
f |= KateDocumentConfig::LocalFiles;
}
if (uiadv->chkBackupRemoteFiles->isChecked()) {
f |= KateDocumentConfig::RemoteFiles;
}
KateDocumentConfig::global()->setBackupFlags(f);
KateDocumentConfig::global()->setBackupPrefix(uiadv->edtBackupPrefix->text());
KateDocumentConfig::global()->setBackupSuffix(uiadv->edtBackupSuffix->text());
KateDocumentConfig::global()->setSwapFileMode(uiadv->cmbSwapFileMode->currentIndex());
KateDocumentConfig::global()->setSwapDirectory(uiadv->kurlSwapDirectory->url().toLocalFile());
KateDocumentConfig::global()->setSwapSyncInterval(uiadv->spbSwapFileSync->value());
KateDocumentConfig::global()->setRemoveSpaces(ui->cbRemoveTrailingSpaces->currentIndex());
KateDocumentConfig::global()->setNewLineAtEof(ui->chkNewLineAtEof->isChecked());
// set both standard and fallback encoding
KateDocumentConfig::global()->setEncoding(KCharsets::charsets()->encodingForName(ui->cmbEncoding->currentText()));
KateGlobalConfig::global()->setProberType((KEncodingProber::ProberType)ui->cmbEncodingDetection->currentIndex());
KateGlobalConfig::global()->setFallbackEncoding(KCharsets::charsets()->encodingForName(ui->cmbEncodingFallback->currentText()));
KateDocumentConfig::global()->setEol(ui->cmbEOL->currentIndex());
KateDocumentConfig::global()->setAllowEolDetection(ui->chkDetectEOL->isChecked());
KateDocumentConfig::global()->setBom(ui->chkEnableBOM->isChecked());
KateDocumentConfig::global()->setLineLengthLimit(ui->lineLengthLimit->value());
KateDocumentConfig::global()->configEnd();
KateGlobalConfig::global()->configEnd();
}
void KateSaveConfigTab::reload()
{
modeConfigPage->reload();
// encodings
ui->cmbEncoding->clear();
ui->cmbEncodingFallback->clear();
QStringList encodings(KCharsets::charsets()->descriptiveEncodingNames());
int insert = 0;
for (int i = 0; i < encodings.count(); i++) {
bool found = false;
QTextCodec *codecForEnc = KCharsets::charsets()->codecForName(KCharsets::charsets()->encodingForName(encodings[i]), found);
if (found) {
ui->cmbEncoding->addItem(encodings[i]);
ui->cmbEncodingFallback->addItem(encodings[i]);
if (codecForEnc == KateDocumentConfig::global()->codec()) {
ui->cmbEncoding->setCurrentIndex(insert);
}
if (codecForEnc == KateGlobalConfig::global()->fallbackCodec()) {
// adjust index for fallback config, has no default!
ui->cmbEncodingFallback->setCurrentIndex(insert);
}
insert++;
}
}
// encoding detection
ui->cmbEncodingDetection->clear();
bool found = false;
for (int i = 0; !KEncodingProber::nameForProberType((KEncodingProber::ProberType) i).isEmpty(); ++i) {
ui->cmbEncodingDetection->addItem(KEncodingProber::nameForProberType((KEncodingProber::ProberType) i));
if (i == KateGlobalConfig::global()->proberType()) {
ui->cmbEncodingDetection->setCurrentIndex(ui->cmbEncodingDetection->count() - 1);
found = true;
}
}
if (!found) {
ui->cmbEncodingDetection->setCurrentIndex(KEncodingProber::Universal);
}
// eol
ui->cmbEOL->setCurrentIndex(KateDocumentConfig::global()->eol());
ui->chkDetectEOL->setChecked(KateDocumentConfig::global()->allowEolDetection());
ui->chkEnableBOM->setChecked(KateDocumentConfig::global()->bom());
ui->lineLengthLimit->setValue(KateDocumentConfig::global()->lineLengthLimit());
ui->cbRemoveTrailingSpaces->setCurrentIndex(KateDocumentConfig::global()->removeSpaces());
ui->chkNewLineAtEof->setChecked(KateDocumentConfig::global()->newLineAtEof());
// other stuff
uint f(KateDocumentConfig::global()->backupFlags());
uiadv->chkBackupLocalFiles->setChecked(f & KateDocumentConfig::LocalFiles);
uiadv->chkBackupRemoteFiles->setChecked(f & KateDocumentConfig::RemoteFiles);
uiadv->edtBackupPrefix->setText(KateDocumentConfig::global()->backupPrefix());
uiadv->edtBackupSuffix->setText(KateDocumentConfig::global()->backupSuffix());
uiadv->cmbSwapFileMode->setCurrentIndex(KateDocumentConfig::global()->swapFileModeRaw());
uiadv->kurlSwapDirectory->setUrl(QUrl::fromLocalFile(KateDocumentConfig::global()->swapDirectory()));
uiadv->spbSwapFileSync->setValue(KateDocumentConfig::global()->swapSyncInterval());
swapFileModeChanged(KateDocumentConfig::global()->swapFileMode());
}
void KateSaveConfigTab::reset()
{
modeConfigPage->reset();
}
void KateSaveConfigTab::defaults()
{
modeConfigPage->defaults();
ui->cbRemoveTrailingSpaces->setCurrentIndex(0);
uiadv->chkBackupLocalFiles->setChecked(true);
uiadv->chkBackupRemoteFiles->setChecked(false);
uiadv->edtBackupPrefix->setText(QString());
uiadv->edtBackupSuffix->setText(QStringLiteral("~"));
uiadv->cmbSwapFileMode->setCurrentIndex(1);
uiadv->kurlSwapDirectory->setDisabled(true);
uiadv->lblSwapDirectory->setDisabled(true);
uiadv->spbSwapFileSync->setValue(15);
}
QString KateSaveConfigTab::name() const
{
return i18n("Open/Save");
}
QString KateSaveConfigTab::fullName() const
{
return i18n("File Opening & Saving");
}
QIcon KateSaveConfigTab::icon() const
{
return QIcon::fromTheme(QStringLiteral("document-save"));
}
//END KateSaveConfigTab
//BEGIN KateHlDownloadDialog
KateHlDownloadDialog::KateHlDownloadDialog(QWidget *parent, const char *name, bool modal)
: QDialog(parent)
{
setWindowTitle(i18n("Highlight Download"));
setObjectName(QString::fromUtf8(name));
setModal(modal);
QVBoxLayout *mainLayout = new QVBoxLayout;
setLayout(mainLayout);
QLabel *label = new QLabel(i18n("Select the syntax highlighting files you want to update:"), this);
mainLayout->addWidget(label);
list = new QTreeWidget(this);
list->setColumnCount(4);
list->setHeaderLabels({ QString(), i18n("Name"), i18n("Installed"), i18n("Latest") });
list->setSelectionMode(QAbstractItemView::MultiSelection);
list->setAllColumnsShowFocus(true);
list->setRootIsDecorated(false);
list->setColumnWidth(0, 22);
mainLayout->addWidget(list);
label = new QLabel(i18n("Note: New versions are selected automatically."), this);
mainLayout->addWidget(label);
// buttons
QDialogButtonBox *buttons = new QDialogButtonBox(this);
mainLayout->addWidget(buttons);
m_installButton = new QPushButton(QIcon::fromTheme(QStringLiteral("dialog-ok")), i18n("&Install"));
m_installButton->setDefault(true);
buttons->addButton(m_installButton, QDialogButtonBox::AcceptRole);
connect(m_installButton, SIGNAL(clicked()), this, SLOT(slotInstall()));
QPushButton *closeButton = new QPushButton;
KGuiItem::assign(closeButton, KStandardGuiItem::cancel());
buttons->addButton(closeButton, QDialogButtonBox::RejectRole);
connect(closeButton, SIGNAL(clicked()), this, SLOT(reject()));
transferJob = KIO::get(QUrl(QStringLiteral("%1update-%2.%3.xml").arg(HLDOWNLOADPATH).arg(KTEXTEDITOR_VERSION_MAJOR).arg(KTEXTEDITOR_VERSION_MINOR)), KIO::Reload);
connect(transferJob, SIGNAL(data(KIO::Job*,QByteArray)),
this, SLOT(listDataReceived(KIO::Job*,QByteArray)));
// void data( KIO::Job *, const QByteArray &data);
resize(450, 400);
}
KateHlDownloadDialog::~KateHlDownloadDialog() {}
/// Split typical version string (\c major.minor.patch) into
/// numeric components, convert 'em to \c unsigned and form a
/// single value that can be compared w/ other versions
/// using relation operators.
/// \note It takes into account only first 3 numbers
unsigned KateHlDownloadDialog::parseVersion(const QString &version_string)
{
unsigned vn[3] = {0, 0, 0};
unsigned idx = 0;
foreach (const QString &n, version_string.split(QLatin1Char('.'))) {
vn[idx++] = n.toUInt();
if (idx == sizeof(vn)) {
break;
}
}
return (((vn[0]) << 16) | ((vn[1]) << 8) | (vn[2]));
}
void KateHlDownloadDialog::listDataReceived(KIO::Job *, const QByteArray &data)
{
if (!transferJob || transferJob->isErrorPage()) {
m_installButton->setEnabled(false);
if (data.size() == 0) {
KMessageBox::error(this, i18n("The list of highlightings could not be found on / retrieved from the server"));
}
return;
}
listData += QLatin1String(data);
qCDebug(LOG_KTE) << QStringLiteral("CurrentListData: ") << listData;
qCDebug(LOG_KTE) << QStringLiteral("Data length: %1").arg(data.size());
qCDebug(LOG_KTE) << QStringLiteral("listData length: %1").arg(listData.length());
if (data.size() == 0) {
if (listData.length() > 0) {
QString installedVersion;
KateHlManager *hlm = KateHlManager::self();
QDomDocument doc;
doc.setContent(listData);
QDomElement DocElem = doc.documentElement();
QDomNode n = DocElem.firstChild();
KateHighlighting *hl = nullptr;
if (n.isNull()) {
qCDebug(LOG_KTE) << QStringLiteral("There is no usable childnode");
}
while (!n.isNull()) {
installedVersion = QStringLiteral(" --");
QDomElement e = n.toElement();
if (!e.isNull()) {
qCDebug(LOG_KTE) << QStringLiteral("NAME: ") << e.tagName() << QStringLiteral(" - ") << e.attribute(QStringLiteral("name"));
}
n = n.nextSibling();
QString Name = e.attribute(QStringLiteral("name"));
- for (int i = 0; i < hlm->highlights(); i++) {
+ for (int i = 0; i < hlm->modeList().size(); i++) {
hl = hlm->getHl(i);
if (hl && hl->name() == Name) {
installedVersion = QLatin1String(" ") + hl->version();
break;
} else {
hl = nullptr;
}
}
// autoselect entry if new or updated.
QTreeWidgetItem *entry = new QTreeWidgetItem(list);
entry->setText(0, QString());
entry->setText(1, e.attribute(QStringLiteral("name")));
entry->setText(2, installedVersion);
entry->setText(3, e.attribute(QStringLiteral("version")));
entry->setText(4, e.attribute(QStringLiteral("url")));
bool is_fresh = false;
if (hl) {
unsigned prev_version = parseVersion(hl->version());
unsigned next_version = parseVersion(e.attribute(QStringLiteral("version")));
is_fresh = prev_version < next_version;
} else {
is_fresh = true;
}
if (is_fresh) {
entry->treeWidget()->setItemSelected(entry, true);
entry->setIcon(0, QIcon::fromTheme((QStringLiteral("get-hot-new-stuff"))));
}
}
list->resizeColumnToContents(1);
list->sortItems(1, Qt::AscendingOrder);
}
}
}
void KateHlDownloadDialog::slotInstall()
{
const QString destdir = QStandardPaths::writableLocation(QStandardPaths::GenericDataLocation) + QLatin1String("/org.kde.syntax-highlighting/syntax/");
QDir(destdir).mkpath(QStringLiteral(".")); // make sure the dir is there
foreach (QTreeWidgetItem *it, list->selectedItems()) {
QUrl src(it->text(4));
QString filename = src.fileName();
// if there is no fileName construct at least something
if (filename.isEmpty()) {
filename = src.path().replace(QLatin1Char('/'), QLatin1Char('_'));
}
QUrl dest = QUrl::fromLocalFile(destdir + filename);
KIO::FileCopyJob *job = KIO::file_copy(src, dest);
KJobWidgets::setWindow(job, this);
job->exec();
}
}
//END KateHlDownloadDialog
//BEGIN KateGotoBar
KateGotoBar::KateGotoBar(KTextEditor::View *view, QWidget *parent)
: KateViewBarWidget(true, parent)
, m_view(view)
{
Q_ASSERT(m_view != nullptr); // this bar widget is pointless w/o a view
QHBoxLayout *topLayout = new QHBoxLayout(centralWidget());
topLayout->setMargin(0);
gotoRange = new QSpinBox(centralWidget());
QLabel *label = new QLabel(i18n("&Go to line:"), centralWidget());
label->setBuddy(gotoRange);
QToolButton *btnOK = new QToolButton(centralWidget());
btnOK->setAutoRaise(true);
btnOK->setIcon(QIcon::fromTheme(QStringLiteral("go-jump")));
btnOK->setText(i18n("Go"));
btnOK->setToolButtonStyle(Qt::ToolButtonTextBesideIcon);
connect(btnOK, SIGNAL(clicked()), this, SLOT(gotoLine()));
topLayout->addWidget(label);
topLayout->addWidget(gotoRange, 1);
topLayout->setStretchFactor(gotoRange, 0);
topLayout->addWidget(btnOK);
topLayout->addStretch();
setFocusProxy(gotoRange);
}
void KateGotoBar::updateData()
{
gotoRange->setMaximum(m_view->document()->lines());
if (!isVisible()) {
gotoRange->setValue(m_view->cursorPosition().line() + 1);
gotoRange->adjustSize(); // ### does not respect the range :-(
}
gotoRange->setFocus(Qt::OtherFocusReason);
gotoRange->selectAll();
}
void KateGotoBar::keyPressEvent(QKeyEvent *event)
{
int key = event->key();
if (key == Qt::Key_Return || key == Qt::Key_Enter) {
gotoLine();
return;
}
KateViewBarWidget::keyPressEvent(event);
}
void KateGotoBar::gotoLine()
{
KTextEditor::ViewPrivate *kv = qobject_cast(m_view);
if (kv && kv->selection() && !kv->config()->persistentSelection()) {
kv->clearSelection();
}
m_view->setCursorPosition(KTextEditor::Cursor(gotoRange->value() - 1, 0));
m_view->setFocus();
emit hideMe();
}
//END KateGotoBar
//BEGIN KateDictionaryBar
KateDictionaryBar::KateDictionaryBar(KTextEditor::ViewPrivate *view, QWidget *parent)
: KateViewBarWidget(true, parent)
, m_view(view)
{
Q_ASSERT(m_view != nullptr); // this bar widget is pointless w/o a view
QHBoxLayout *topLayout = new QHBoxLayout(centralWidget());
topLayout->setMargin(0);
//topLayout->setSpacing(spacingHint());
m_dictionaryComboBox = new Sonnet::DictionaryComboBox(centralWidget());
connect(m_dictionaryComboBox, SIGNAL(dictionaryChanged(QString)),
this, SLOT(dictionaryChanged(QString)));
connect(view->doc(), SIGNAL(defaultDictionaryChanged(KTextEditor::DocumentPrivate*)),
this, SLOT(updateData()));
QLabel *label = new QLabel(i18n("Dictionary:"), centralWidget());
label->setBuddy(m_dictionaryComboBox);
topLayout->addWidget(label);
topLayout->addWidget(m_dictionaryComboBox, 1);
topLayout->setStretchFactor(m_dictionaryComboBox, 0);
topLayout->addStretch();
}
KateDictionaryBar::~KateDictionaryBar()
{
}
void KateDictionaryBar::updateData()
{
KTextEditor::DocumentPrivate *document = m_view->doc();
QString dictionary = document->defaultDictionary();
if (dictionary.isEmpty()) {
dictionary = Sonnet::Speller().defaultLanguage();
}
m_dictionaryComboBox->setCurrentByDictionary(dictionary);
}
void KateDictionaryBar::dictionaryChanged(const QString &dictionary)
{
KTextEditor::Range selection = m_view->selectionRange();
if (selection.isValid() && !selection.isEmpty()) {
m_view->doc()->setDictionary(dictionary, selection);
} else {
m_view->doc()->setDefaultDictionary(dictionary);
}
}
//END KateGotoBar
//BEGIN KateModOnHdPrompt
KateModOnHdPrompt::KateModOnHdPrompt(KTextEditor::DocumentPrivate *doc,
KTextEditor::ModificationInterface::ModifiedOnDiskReason modtype,
const QString &reason)
: QObject(doc)
, m_doc(doc)
, m_modtype(modtype)
, m_proc(nullptr)
, m_diffFile(nullptr)
, m_diffAction(nullptr)
{
m_message = new KTextEditor::Message(reason, KTextEditor::Message::Information);
m_message->setPosition(KTextEditor::Message::AboveView);
m_message->setWordWrap(true);
// If the file isn't deleted, present a diff button
const bool onDiskDeleted = modtype == KTextEditor::ModificationInterface::OnDiskDeleted;
if (!onDiskDeleted) {
if (!QStandardPaths::findExecutable(QStringLiteral("diff")).isEmpty()) {
m_diffAction = new QAction(i18n("View &Difference"), this);
m_diffAction->setToolTip(i18n("Shows a diff of the changes"));
m_message->addAction(m_diffAction, false);
connect(m_diffAction, SIGNAL(triggered()), this, SLOT(slotDiff()));
}
QAction * aReload = new QAction(i18n("&Reload"), this);
aReload->setIcon(QIcon::fromTheme(QStringLiteral("view-refresh")));
aReload->setToolTip(i18n("Reload the file from disk. Unsaved changes will be lost."));
m_message->addAction(aReload);
connect(aReload, SIGNAL(triggered()), this, SIGNAL(reloadTriggered()));
} else {
QAction * aSaveAs = new QAction(i18n("&Save As..."), this);
aSaveAs->setIcon(QIcon::fromTheme(QStringLiteral("document-save-as")));
aSaveAs->setToolTip(i18n("Lets you select a location and save the file again."));
m_message->addAction(aSaveAs, false);
connect(aSaveAs, SIGNAL(triggered()), this, SIGNAL(saveAsTriggered()));
}
QAction * aIgnore = new QAction(i18n("&Ignore"), this);
aIgnore->setToolTip(i18n("Ignores the changes on disk without any action."));
aIgnore->setIcon(KStandardGuiItem::overwrite().icon());
m_message->addAction(aIgnore);
connect(aIgnore, SIGNAL(triggered()), this, SIGNAL(ignoreTriggered()));
m_doc->postMessage(m_message);
}
KateModOnHdPrompt::~KateModOnHdPrompt()
{
delete m_proc;
m_proc = nullptr;
if (m_diffFile) {
m_diffFile->setAutoRemove(true);
delete m_diffFile;
m_diffFile = nullptr;
}
delete m_message;
}
void KateModOnHdPrompt::slotDiff()
{
if (m_diffFile) {
return;
}
m_diffFile = new QTemporaryFile();
m_diffFile->open();
// Start a KProcess that creates a diff
m_proc = new KProcess(this);
m_proc->setOutputChannelMode(KProcess::MergedChannels);
*m_proc << QStringLiteral("diff") << QLatin1String("-u")
<< QStringLiteral("-") << m_doc->url().toLocalFile();
connect(m_proc, SIGNAL(readyRead()), this, SLOT(slotDataAvailable()));
connect(m_proc, SIGNAL(finished(int,QProcess::ExitStatus)), this, SLOT(slotPDone()));
// disable the diff button, to hinder the user to run it twice.
m_diffAction->setEnabled(false);
m_proc->start();
QTextStream ts(m_proc);
int lastln = m_doc->lines() - 1;
for (int l = 0; l < lastln; ++l) {
ts << m_doc->line(l) << '\n';
}
ts << m_doc->line(lastln);
ts.flush();
m_proc->closeWriteChannel();
}
void KateModOnHdPrompt::slotDataAvailable()
{
m_diffFile->write(m_proc->readAll());
}
void KateModOnHdPrompt::slotPDone()
{
m_diffAction->setEnabled(true);
const QProcess::ExitStatus es = m_proc->exitStatus();
delete m_proc;
m_proc = nullptr;
if (es != QProcess::NormalExit) {
KMessageBox::sorry(nullptr,
i18n("The diff command failed. Please make sure that "
"diff(1) is installed and in your PATH."),
i18n("Error Creating Diff"));
delete m_diffFile;
m_diffFile = nullptr;
return;
}
if (m_diffFile->size() == 0) {
KMessageBox::information(nullptr,
i18n("The files are identical."),
i18n("Diff Output"));
delete m_diffFile;
m_diffFile = nullptr;
return;
}
m_diffFile->setAutoRemove(false);
QUrl url = QUrl::fromLocalFile(m_diffFile->fileName());
delete m_diffFile;
m_diffFile = nullptr;
// KRun::runUrl should delete the file, once the client exits
KRun::runUrl(url, QStringLiteral("text/x-patch"), nullptr, KRun::RunFlags(KRun::DeleteTemporaryFiles));
}
//END KateModOnHdPrompt
diff --git a/src/document/katedocument.cpp b/src/document/katedocument.cpp
index 2da7f5df..05aa222e 100644
--- a/src/document/katedocument.cpp
+++ b/src/document/katedocument.cpp
@@ -1,5991 +1,5989 @@
/* This file is part of the KDE libraries
Copyright (C) 2001-2004 Christoph Cullmann
Copyright (C) 2001 Joseph Wenninger
Copyright (C) 1999 Jochen Wilhelmy
Copyright (C) 2006 Hamish Rodda
Copyright (C) 2007 Mirko Stocker
Copyright (C) 2009-2010 Michel Ludwig
Copyright (C) 2013 Gerald Senarclens de Grancy
Copyright (C) 2013 Andrey Matveyakin
This library is free software; you can redistribute it and/or
modify it under the terms of the GNU Library General Public
License version 2 as published by the Free Software Foundation.
This library 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
Library General Public License for more details.
You should have received a copy of the GNU Library General Public License
along with this library; see the file COPYING.LIB. If not, write to
the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
Boston, MA 02111-13020, USA.
*/
//BEGIN includes
#include "config.h"
#include "katedocument.h"
#include "kateglobal.h"
#include "katedialogs.h"
#include "katehighlight.h"
#include "kateview.h"
#include "kateautoindent.h"
#include "katetextline.h"
#include "katerenderer.h"
#include "kateregexp.h"
#include "kateplaintextsearch.h"
#include "kateregexpsearch.h"
#include "kateconfig.h"
#include "katemodemanager.h"
#include "kateschema.h"
#include "katebuffer.h"
#include "kateundomanager.h"
#include "spellcheck/prefixstore.h"
#include "spellcheck/ontheflycheck.h"
#include "spellcheck/spellcheck.h"
#include "katescriptmanager.h"
#include "kateswapfile.h"
#include "katepartdebug.h"
#include "printing/kateprinter.h"
#include "kateabstractinputmode.h"
#include "katetemplatehandler.h"
#if EDITORCONFIG_FOUND
#include "editorconfig.h"
#endif
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#if LIBGIT2_FOUND
#include
#include
#include
#endif
//END includes
#if 0
#define EDIT_DEBUG qCDebug(LOG_KTE)
#else
#define EDIT_DEBUG if (0) qCDebug(LOG_KTE)
#endif
template
static int indexOf(const std::initializer_list & list, const E& entry)
{
auto it = std::find(list.begin(), list.end(), entry);
return it == list.end() ? -1 : std::distance(list.begin(), it);
}
template
static bool contains(const std::initializer_list & list, const E& entry)
{
return indexOf(list, entry) >= 0;
}
static inline QChar matchingStartBracket(QChar c, bool withQuotes)
{
switch (c.toLatin1()) {
case '}': return QLatin1Char('{');
case ']': return QLatin1Char('[');
case ')': return QLatin1Char('(');
case '\'': return withQuotes ? QLatin1Char('\'') : QChar();
case '"': return withQuotes ? QLatin1Char('"') : QChar();
}
return QChar();
}
static inline QChar matchingEndBracket(QChar c, bool withQuotes)
{
switch (c.toLatin1()) {
case '{': return QLatin1Char('}');
case '[': return QLatin1Char(']');
case '(': return QLatin1Char(')');
case '\'': return withQuotes ? QLatin1Char('\'') : QChar();
case '"': return withQuotes ? QLatin1Char('"') : QChar();
}
return QChar();
}
static inline QChar matchingBracket(QChar c, bool withQuotes)
{
QChar bracket = matchingStartBracket(c, withQuotes);
if (bracket.isNull()) {
bracket = matchingEndBracket(c, false);
}
return bracket;
}
static inline bool isStartBracket(const QChar &c)
{
return ! matchingEndBracket(c, false).isNull();
}
static inline bool isEndBracket(const QChar &c)
{
return ! matchingStartBracket(c, false).isNull();
}
static inline bool isBracket(const QChar &c)
{
return isStartBracket(c) || isEndBracket(c);
}
/**
* normalize given url
* @param url input url
* @return normalized url
*/
static QUrl normalizeUrl (const QUrl &url)
{
/**
* only normalize local urls
*/
if (url.isEmpty() || !url.isLocalFile())
return url;
/**
* don't normalize if not existing!
* canonicalFilePath won't work!
*/
const QString normalizedUrl(QFileInfo(url.toLocalFile()).canonicalFilePath());
if (normalizedUrl.isEmpty())
return url;
/**
* else: use canonicalFilePath to normalize
*/
return QUrl::fromLocalFile(normalizedUrl);
}
//BEGIN d'tor, c'tor
//
// KTextEditor::DocumentPrivate Constructor
//
KTextEditor::DocumentPrivate::DocumentPrivate(bool bSingleViewMode,
bool bReadOnly, QWidget *parentWidget,
QObject *parent)
: KTextEditor::Document (this, parent),
m_bSingleViewMode(bSingleViewMode),
m_bReadOnly(bReadOnly),
m_undoManager(new KateUndoManager(this)),
m_buffer(new KateBuffer(this)),
m_indenter(new KateAutoIndent(this)),
m_docName(QStringLiteral("need init")),
m_fileType(QStringLiteral("Normal")),
m_config(new KateDocumentConfig(this))
{
/**
* no plugins from kparts here
*/
setPluginLoadingMode (DoNotLoadPlugins);
/**
* pass on our component data, do this after plugin loading is off
*/
setComponentData(KTextEditor::EditorPrivate::self()->aboutData());
/**
* avoid spamming plasma and other window managers with progress dialogs
* we show such stuff inline in the views!
*/
setProgressInfoEnabled(false);
// register doc at factory
KTextEditor::EditorPrivate::self()->registerDocument(this);
// normal hl
m_buffer->setHighlight(0);
// swap file
m_swapfile = (config()->swapFileMode() == KateDocumentConfig::DisableSwapFile) ? nullptr : new Kate::SwapFile(this);
// important, fill in the config into the indenter we use...
m_indenter->updateConfig();
// some nice signals from the buffer
connect(m_buffer, SIGNAL(tagLines(int,int)), this, SLOT(tagLines(int,int)));
// if the user changes the highlight with the dialog, notify the doc
connect(KateHlManager::self(), SIGNAL(changed()), SLOT(internalHlChanged()));
// signals for mod on hd
connect(KTextEditor::EditorPrivate::self()->dirWatch(), SIGNAL(dirty(QString)),
this, SLOT(slotModOnHdDirty(QString)));
connect(KTextEditor::EditorPrivate::self()->dirWatch(), SIGNAL(created(QString)),
this, SLOT(slotModOnHdCreated(QString)));
connect(KTextEditor::EditorPrivate::self()->dirWatch(), SIGNAL(deleted(QString)),
this, SLOT(slotModOnHdDeleted(QString)));
/**
* singleshot timer to handle updates of mod on hd state delayed
*/
m_modOnHdTimer.setSingleShot(true);
m_modOnHdTimer.setInterval(200);
connect(&m_modOnHdTimer, SIGNAL(timeout()), this, SLOT(slotDelayedHandleModOnHd()));
/**
* load handling
* this is needed to ensure we signal the user if a file ist still loading
* and to disallow him to edit in that time
*/
connect(this, SIGNAL(started(KIO::Job*)), this, SLOT(slotStarted(KIO::Job*)));
connect(this, SIGNAL(completed()), this, SLOT(slotCompleted()));
connect(this, SIGNAL(canceled(QString)), this, SLOT(slotCanceled()));
connect(this, SIGNAL(urlChanged(QUrl)), this, SLOT(slotUrlChanged(QUrl)));
// update doc name
updateDocName();
// if single view mode, like in the konqui embedding, create a default view ;)
// be lazy, only create it now, if any parentWidget is given, otherwise widget()
// will create it on demand...
if (m_bSingleViewMode && parentWidget) {
KTextEditor::View *view = (KTextEditor::View *)createView(parentWidget);
insertChildClient(view);
view->setContextMenu(view->defaultContextMenu());
setWidget(view);
}
connect(m_undoManager, SIGNAL(undoChanged()), this, SIGNAL(undoChanged()));
connect(m_undoManager, SIGNAL(undoStart(KTextEditor::Document*)), this, SIGNAL(editingStarted(KTextEditor::Document*)));
connect(m_undoManager, SIGNAL(undoEnd(KTextEditor::Document*)), this, SIGNAL(editingFinished(KTextEditor::Document*)));
connect(m_undoManager, SIGNAL(redoStart(KTextEditor::Document*)), this, SIGNAL(editingStarted(KTextEditor::Document*)));
connect(m_undoManager, SIGNAL(redoEnd(KTextEditor::Document*)), this, SIGNAL(editingFinished(KTextEditor::Document*)));
connect(this, SIGNAL(sigQueryClose(bool*,bool*)), this, SLOT(slotQueryClose_save(bool*,bool*)));
connect(this, &KTextEditor::DocumentPrivate::textRemoved, this, &KTextEditor::DocumentPrivate::saveEditingPositions);
connect(this, &KTextEditor::DocumentPrivate::textInserted, this, &KTextEditor::DocumentPrivate::saveEditingPositions);
connect(this, SIGNAL(aboutToInvalidateMovingInterfaceContent(KTextEditor::Document*)), this, SLOT(clearEditingPosStack()));
onTheFlySpellCheckingEnabled(config()->onTheFlySpellCheck());
}
//
// KTextEditor::DocumentPrivate Destructor
//
KTextEditor::DocumentPrivate::~DocumentPrivate()
{
// delete pending mod-on-hd message, if applicable
delete m_modOnHdHandler;
/**
* we are about to delete cursors/ranges/...
*/
emit aboutToDeleteMovingInterfaceContent(this);
// kill it early, it has ranges!
delete m_onTheFlyChecker;
m_onTheFlyChecker = nullptr;
clearDictionaryRanges();
// Tell the world that we're about to close (== destruct)
// Apps must receive this in a direct signal-slot connection, and prevent
// any further use of interfaces once they return.
emit aboutToClose(this);
// remove file from dirwatch
deactivateDirWatch();
// thanks for offering, KPart, but we're already self-destructing
setAutoDeleteWidget(false);
setAutoDeletePart(false);
// clean up remaining views
qDeleteAll (m_views.keys());
m_views.clear();
// cu marks
for (QHash::const_iterator i = m_marks.constBegin(); i != m_marks.constEnd(); ++i) {
delete i.value();
}
m_marks.clear();
delete m_config;
KTextEditor::EditorPrivate::self()->deregisterDocument(this);
}
//END
void KTextEditor::DocumentPrivate::saveEditingPositions(KTextEditor::Document *, const KTextEditor::Range &range)
{
if (m_editingStackPosition != m_editingStack.size() - 1) {
m_editingStack.resize(m_editingStackPosition);
}
KTextEditor::MovingInterface *moving = qobject_cast(this);
const auto c = range.start();
QSharedPointer mc (moving->newMovingCursor(c));
if (!m_editingStack.isEmpty() && c.line() == m_editingStack.top()->line()) {
m_editingStack.pop();
}
m_editingStack.push(mc);
if (m_editingStack.size() > s_editingStackSizeLimit) {
m_editingStack.removeFirst();
}
m_editingStackPosition = m_editingStack.size() - 1;
}
KTextEditor::Cursor KTextEditor::DocumentPrivate::lastEditingPosition(EditingPositionKind nextOrPrev, KTextEditor::Cursor currentCursor)
{
if (m_editingStack.isEmpty()) {
return KTextEditor::Cursor::invalid();
}
auto targetPos = m_editingStack.at(m_editingStackPosition)->toCursor();
if (targetPos == currentCursor) {
if (nextOrPrev == Previous) {
m_editingStackPosition--;
}
else {
m_editingStackPosition++;
}
m_editingStackPosition = qBound(0, m_editingStackPosition, m_editingStack.size() - 1);
}
return m_editingStack.at(m_editingStackPosition)->toCursor();
}
void KTextEditor::DocumentPrivate::clearEditingPosStack()
{
m_editingStack.clear();
m_editingStackPosition = -1;
}
// on-demand view creation
QWidget *KTextEditor::DocumentPrivate::widget()
{
// no singleViewMode -> no widget()...
if (!singleViewMode()) {
return nullptr;
}
// does a widget exist already? use it!
if (KTextEditor::Document::widget()) {
return KTextEditor::Document::widget();
}
// create and return one...
KTextEditor::View *view = (KTextEditor::View *)createView(nullptr);
insertChildClient(view);
view->setContextMenu(view->defaultContextMenu());
setWidget(view);
return view;
}
//BEGIN KTextEditor::Document stuff
KTextEditor::View *KTextEditor::DocumentPrivate::createView(QWidget *parent, KTextEditor::MainWindow *mainWindow)
{
KTextEditor::ViewPrivate *newView = new KTextEditor::ViewPrivate(this, parent, mainWindow);
if (m_fileChangedDialogsActivated) {
connect(newView, SIGNAL(focusIn(KTextEditor::View*)), this, SLOT(slotModifiedOnDisk()));
}
emit viewCreated(this, newView);
// post existing messages to the new view, if no specific view is given
foreach (KTextEditor::Message *message, m_messageHash.keys()) {
if (!message->view()) {
newView->postMessage(message, m_messageHash[message]);
}
}
return newView;
}
KTextEditor::Range KTextEditor::DocumentPrivate::rangeOnLine(KTextEditor::Range range, int line) const
{
const int col1 = toVirtualColumn(range.start());
const int col2 = toVirtualColumn(range.end());
return KTextEditor::Range(line, fromVirtualColumn(line, col1), line, fromVirtualColumn(line, col2));
}
//BEGIN KTextEditor::EditInterface stuff
bool KTextEditor::DocumentPrivate::isEditingTransactionRunning() const
{
return editSessionNumber > 0;
}
QString KTextEditor::DocumentPrivate::text() const
{
return m_buffer->text();
}
QString KTextEditor::DocumentPrivate::text(const KTextEditor::Range &range, bool blockwise) const
{
if (!range.isValid()) {
qCWarning(LOG_KTE) << "Text requested for invalid range" << range;
return QString();
}
QString s;
if (range.start().line() == range.end().line()) {
if (range.start().column() > range.end().column()) {
return QString();
}
Kate::TextLine textLine = m_buffer->plainLine(range.start().line());
if (!textLine) {
return QString();
}
return textLine->string(range.start().column(), range.end().column() - range.start().column());
} else {
for (int i = range.start().line(); (i <= range.end().line()) && (i < m_buffer->count()); ++i) {
Kate::TextLine textLine = m_buffer->plainLine(i);
if (!blockwise) {
if (i == range.start().line()) {
s.append(textLine->string(range.start().column(), textLine->length() - range.start().column()));
} else if (i == range.end().line()) {
s.append(textLine->string(0, range.end().column()));
} else {
s.append(textLine->string());
}
} else {
KTextEditor::Range subRange = rangeOnLine(range, i);
s.append(textLine->string(subRange.start().column(), subRange.columnWidth()));
}
if (i < range.end().line()) {
s.append(QLatin1Char('\n'));
}
}
}
return s;
}
QChar KTextEditor::DocumentPrivate::characterAt(const KTextEditor::Cursor &position) const
{
Kate::TextLine textLine = m_buffer->plainLine(position.line());
if (!textLine) {
return QChar();
}
return textLine->at(position.column());
}
QString KTextEditor::DocumentPrivate::wordAt(const KTextEditor::Cursor &cursor) const
{
return text(wordRangeAt(cursor));
}
KTextEditor::Range KTextEditor::DocumentPrivate::wordRangeAt(const KTextEditor::Cursor &cursor) const
{
// get text line
const int line = cursor.line();
Kate::TextLine textLine = m_buffer->plainLine(line);
if (!textLine) {
return KTextEditor::Range::invalid();
}
// make sure the cursor is
const int lineLenth = textLine->length();
if (cursor.column() > lineLenth) {
return KTextEditor::Range::invalid();
}
int start = cursor.column();
int end = start;
while (start > 0 && highlight()->isInWord(textLine->at(start - 1), textLine->attribute(start - 1))) {
start--;
}
while (end < lineLenth && highlight()->isInWord(textLine->at(end), textLine->attribute(end))) {
end++;
}
return KTextEditor::Range(line, start, line, end);
}
bool KTextEditor::DocumentPrivate::isValidTextPosition(const KTextEditor::Cursor& cursor) const
{
const int ln = cursor.line();
const int col = cursor.column();
// cursor in document range?
if (ln < 0 || col < 0 || ln >= lines() || col > lineLength(ln)) {
return false;
}
const QString str = line(ln);
Q_ASSERT(str.length() >= col);
// cursor at end of line?
const int len = lineLength(ln);
if (col == 0 || col == len) {
return true;
}
// cursor in the middle of a valid utf32-surrogate?
return (! str.at(col).isLowSurrogate())
|| (! str.at(col-1).isHighSurrogate());
}
QStringList KTextEditor::DocumentPrivate::textLines(const KTextEditor::Range &range, bool blockwise) const
{
QStringList ret;
if (!range.isValid()) {
qCWarning(LOG_KTE) << "Text requested for invalid range" << range;
return ret;
}
if (blockwise && (range.start().column() > range.end().column())) {
return ret;
}
if (range.start().line() == range.end().line()) {
Q_ASSERT(range.start() <= range.end());
Kate::TextLine textLine = m_buffer->plainLine(range.start().line());
if (!textLine) {
return ret;
}
ret << textLine->string(range.start().column(), range.end().column() - range.start().column());
} else {
for (int i = range.start().line(); (i <= range.end().line()) && (i < m_buffer->count()); ++i) {
Kate::TextLine textLine = m_buffer->plainLine(i);
if (!blockwise) {
if (i == range.start().line()) {
ret << textLine->string(range.start().column(), textLine->length() - range.start().column());
} else if (i == range.end().line()) {
ret << textLine->string(0, range.end().column());
} else {
ret << textLine->string();
}
} else {
KTextEditor::Range subRange = rangeOnLine(range, i);
ret << textLine->string(subRange.start().column(), subRange.columnWidth());
}
}
}
return ret;
}
QString KTextEditor::DocumentPrivate::line(int line) const
{
Kate::TextLine l = m_buffer->plainLine(line);
if (!l) {
return QString();
}
return l->string();
}
bool KTextEditor::DocumentPrivate::setText(const QString &s)
{
if (!isReadWrite()) {
return false;
}
QList msave;
foreach (KTextEditor::Mark *mark, m_marks) {
msave.append(*mark);
}
editStart();
// delete the text
clear();
// insert the new text
insertText(KTextEditor::Cursor(), s);
editEnd();
foreach (KTextEditor::Mark mark, msave) {
setMark(mark.line, mark.type);
}
return true;
}
bool KTextEditor::DocumentPrivate::setText(const QStringList &text)
{
if (!isReadWrite()) {
return false;
}
QList msave;
foreach (KTextEditor::Mark *mark, m_marks) {
msave.append(*mark);
}
editStart();
// delete the text
clear();
// insert the new text
insertText(KTextEditor::Cursor::start(), text);
editEnd();
foreach (KTextEditor::Mark mark, msave) {
setMark(mark.line, mark.type);
}
return true;
}
bool KTextEditor::DocumentPrivate::clear()
{
if (!isReadWrite()) {
return false;
}
foreach (KTextEditor::ViewPrivate *view, m_views) {
view->clear();
view->tagAll();
view->update();
}
clearMarks();
emit aboutToInvalidateMovingInterfaceContent(this);
m_buffer->invalidateRanges();
emit aboutToRemoveText(documentRange());
return editRemoveLines(0, lastLine());
}
bool KTextEditor::DocumentPrivate::insertText(const KTextEditor::Cursor &position, const QString &text, bool block)
{
if (!isReadWrite()) {
return false;
}
if (text.isEmpty()) {
return true;
}
editStart();
int currentLine = position.line();
int currentLineStart = 0;
const int totalLength = text.length();
int insertColumn = position.column();
// pad with empty lines, if insert position is after last line
if (position.line() > lines()) {
int line = lines();
while (line <= position.line()) {
editInsertLine(line, QString());
line++;
}
}
const int tabWidth = config()->tabWidth();
static const QChar newLineChar(QLatin1Char('\n'));
int insertColumnExpanded = insertColumn;
Kate::TextLine l = plainKateTextLine(currentLine);
if (l) {
insertColumnExpanded = l->toVirtualColumn(insertColumn, tabWidth);
}
int positionColumnExpanded = insertColumnExpanded;
int pos = 0;
for (; pos < totalLength; pos++) {
const QChar &ch = text.at(pos);
if (ch == newLineChar) {
// Only perform the text insert if there is text to insert
if (currentLineStart < pos) {
editInsertText(currentLine, insertColumn, text.mid(currentLineStart, pos - currentLineStart));
}
if (!block) {
editWrapLine(currentLine, insertColumn + pos - currentLineStart);
insertColumn = 0;
}
currentLine++;
l = plainKateTextLine(currentLine);
if (block) {
if (currentLine == lastLine() + 1) {
editInsertLine(currentLine, QString());
}
insertColumn = positionColumnExpanded;
if (l) {
insertColumn = l->fromVirtualColumn(insertColumn, tabWidth);
}
}
currentLineStart = pos + 1;
if (l) {
insertColumnExpanded = l->toVirtualColumn(insertColumn, tabWidth);
}
}
}
// Only perform the text insert if there is text to insert
if (currentLineStart < pos) {
editInsertText(currentLine, insertColumn, text.mid(currentLineStart, pos - currentLineStart));
}
editEnd();
return true;
}
bool KTextEditor::DocumentPrivate::insertText(const KTextEditor::Cursor &position, const QStringList &textLines, bool block)
{
if (!isReadWrite()) {
return false;
}
// just reuse normal function
return insertText(position, textLines.join(QStringLiteral("\n")), block);
}
bool KTextEditor::DocumentPrivate::removeText(const KTextEditor::Range &_range, bool block)
{
KTextEditor::Range range = _range;
if (!isReadWrite()) {
return false;
}
// Should now be impossible to trigger with the new Range class
Q_ASSERT(range.start().line() <= range.end().line());
if (range.start().line() > lastLine()) {
return false;
}
if (!block) {
emit aboutToRemoveText(range);
}
editStart();
if (!block) {
if (range.end().line() > lastLine()) {
range.setEnd(KTextEditor::Cursor(lastLine() + 1, 0));
}
if (range.onSingleLine()) {
editRemoveText(range.start().line(), range.start().column(), range.columnWidth());
} else {
int from = range.start().line();
int to = range.end().line();
// remove last line
if (to <= lastLine()) {
editRemoveText(to, 0, range.end().column());
}
// editRemoveLines() will be called on first line (to remove bookmark)
if (range.start().column() == 0 && from > 0) {
--from;
}
// remove middle lines
editRemoveLines(from + 1, to - 1);
// remove first line if not already removed by editRemoveLines()
if (range.start().column() > 0 || range.start().line() == 0) {
editRemoveText(from, range.start().column(), m_buffer->plainLine(from)->length() - range.start().column());
editUnWrapLine(from);
}
}
} // if ( ! block )
else {
int startLine = qMax(0, range.start().line());
int vc1 = toVirtualColumn(range.start());
int vc2 = toVirtualColumn(range.end());
for (int line = qMin(range.end().line(), lastLine()); line >= startLine; --line) {
int col1 = fromVirtualColumn(line, vc1);
int col2 = fromVirtualColumn(line, vc2);
editRemoveText(line, qMin(col1, col2), qAbs(col2 - col1));
}
}
editEnd();
return true;
}
bool KTextEditor::DocumentPrivate::insertLine(int l, const QString &str)
{
if (!isReadWrite()) {
return false;
}
if (l < 0 || l > lines()) {
return false;
}
return editInsertLine(l, str);
}
bool KTextEditor::DocumentPrivate::insertLines(int line, const QStringList &text)
{
if (!isReadWrite()) {
return false;
}
if (line < 0 || line > lines()) {
return false;
}
bool success = true;
foreach (const QString &string, text) {
success &= editInsertLine(line++, string);
}
return success;
}
bool KTextEditor::DocumentPrivate::removeLine(int line)
{
if (!isReadWrite()) {
return false;
}
if (line < 0 || line > lastLine()) {
return false;
}
return editRemoveLine(line);
}
int KTextEditor::DocumentPrivate::totalCharacters() const
{
int l = 0;
for (int i = 0; i < m_buffer->count(); ++i) {
Kate::TextLine line = m_buffer->plainLine(i);
if (line) {
l += line->length();
}
}
return l;
}
int KTextEditor::DocumentPrivate::lines() const
{
return m_buffer->count();
}
int KTextEditor::DocumentPrivate::lineLength(int line) const
{
if (line < 0 || line > lastLine()) {
return -1;
}
Kate::TextLine l = m_buffer->plainLine(line);
if (!l) {
return -1;
}
return l->length();
}
bool KTextEditor::DocumentPrivate::isLineModified(int line) const
{
if (line < 0 || line >= lines()) {
return false;
}
Kate::TextLine l = m_buffer->plainLine(line);
Q_ASSERT(l);
return l->markedAsModified();
}
bool KTextEditor::DocumentPrivate::isLineSaved(int line) const
{
if (line < 0 || line >= lines()) {
return false;
}
Kate::TextLine l = m_buffer->plainLine(line);
Q_ASSERT(l);
return l->markedAsSavedOnDisk();
}
bool KTextEditor::DocumentPrivate::isLineTouched(int line) const
{
if (line < 0 || line >= lines()) {
return false;
}
Kate::TextLine l = m_buffer->plainLine(line);
Q_ASSERT(l);
return l->markedAsModified() || l->markedAsSavedOnDisk();
}
//END
//BEGIN KTextEditor::EditInterface internal stuff
//
// Starts an edit session with (or without) undo, update of view disabled during session
//
bool KTextEditor::DocumentPrivate::editStart()
{
editSessionNumber++;
if (editSessionNumber > 1) {
return false;
}
editIsRunning = true;
m_undoManager->editStart();
foreach (KTextEditor::ViewPrivate *view, m_views) {
view->editStart();
}
m_buffer->editStart();
return true;
}
//
// End edit session and update Views
//
bool KTextEditor::DocumentPrivate::editEnd()
{
if (editSessionNumber == 0) {
Q_ASSERT(0);
return false;
}
// wrap the new/changed text, if something really changed!
if (m_buffer->editChanged() && (editSessionNumber == 1))
if (m_undoManager->isActive() && config()->wordWrap()) {
wrapText(m_buffer->editTagStart(), m_buffer->editTagEnd());
}
editSessionNumber--;
if (editSessionNumber > 0) {
return false;
}
// end buffer edit, will trigger hl update
// this will cause some possible adjustment of tagline start/end
m_buffer->editEnd();
m_undoManager->editEnd();
// edit end for all views !!!!!!!!!
foreach (KTextEditor::ViewPrivate *view, m_views) {
view->editEnd(m_buffer->editTagStart(), m_buffer->editTagEnd(), m_buffer->editTagFrom());
}
if (m_buffer->editChanged()) {
setModified(true);
emit textChanged(this);
}
editIsRunning = false;
return true;
}
void KTextEditor::DocumentPrivate::pushEditState()
{
editStateStack.push(editSessionNumber);
}
void KTextEditor::DocumentPrivate::popEditState()
{
if (editStateStack.isEmpty()) {
return;
}
int count = editStateStack.pop() - editSessionNumber;
while (count < 0) {
++count;
editEnd();
}
while (count > 0) {
--count;
editStart();
}
}
void KTextEditor::DocumentPrivate::inputMethodStart()
{
m_undoManager->inputMethodStart();
}
void KTextEditor::DocumentPrivate::inputMethodEnd()
{
m_undoManager->inputMethodEnd();
}
bool KTextEditor::DocumentPrivate::wrapText(int startLine, int endLine)
{
if (startLine < 0 || endLine < 0) {
return false;
}
if (!isReadWrite()) {
return false;
}
int col = config()->wordWrapAt();
if (col == 0) {
return false;
}
editStart();
for (int line = startLine; (line <= endLine) && (line < lines()); line++) {
Kate::TextLine l = kateTextLine(line);
if (!l) {
break;
}
//qCDebug(LOG_KTE) << "try wrap line: " << line;
if (l->virtualLength(m_buffer->tabWidth()) > col) {
Kate::TextLine nextl = kateTextLine(line + 1);
//qCDebug(LOG_KTE) << "do wrap line: " << line;
int eolPosition = l->length() - 1;
// take tabs into account here, too
int x = 0;
const QString &t = l->string();
int z2 = 0;
for (; z2 < l->length(); z2++) {
static const QChar tabChar(QLatin1Char('\t'));
if (t.at(z2) == tabChar) {
x += m_buffer->tabWidth() - (x % m_buffer->tabWidth());
} else {
x++;
}
if (x > col) {
break;
}
}
const int colInChars = qMin(z2, l->length() - 1);
int searchStart = colInChars;
// If where we are wrapping is an end of line and is a space we don't
// want to wrap there
if (searchStart == eolPosition && t.at(searchStart).isSpace()) {
searchStart--;
}
// Scan backwards looking for a place to break the line
// We are not interested in breaking at the first char
// of the line (if it is a space), but we are at the second
// anders: if we can't find a space, try breaking on a word
// boundary, using KateHighlight::canBreakAt().
// This could be a priority (setting) in the hl/filetype/document
int z = -1;
int nw = -1; // alternative position, a non word character
for (z = searchStart; z >= 0; z--) {
if (t.at(z).isSpace()) {
break;
}
if ((nw < 0) && highlight()->canBreakAt(t.at(z), l->attribute(z))) {
nw = z;
}
}
if (z >= 0) {
// So why don't we just remove the trailing space right away?
// Well, the (view's) cursor may be directly in front of that space
// (user typing text before the last word on the line), and if that
// happens, the cursor would be moved to the next line, which is not
// what we want (bug #106261)
z++;
} else {
// There was no space to break at so break at a nonword character if
// found, or at the wrapcolumn ( that needs be configurable )
// Don't try and add any white space for the break
if ((nw >= 0) && nw < colInChars) {
nw++; // break on the right side of the character
}
z = (nw >= 0) ? nw : colInChars;
}
if (nextl && !nextl->isAutoWrapped()) {
editWrapLine(line, z, true);
editMarkLineAutoWrapped(line + 1, true);
endLine++;
} else {
if (nextl && (nextl->length() > 0) && !nextl->at(0).isSpace() && ((l->length() < 1) || !l->at(l->length() - 1).isSpace())) {
editInsertText(line + 1, 0, QLatin1String(" "));
}
bool newLineAdded = false;
editWrapLine(line, z, false, &newLineAdded);
editMarkLineAutoWrapped(line + 1, true);
endLine++;
}
}
}
editEnd();
return true;
}
bool KTextEditor::DocumentPrivate::editInsertText(int line, int col, const QString &s)
{
// verbose debug
EDIT_DEBUG << "editInsertText" << line << col << s;
if (line < 0 || col < 0) {
return false;
}
if (!isReadWrite()) {
return false;
}
Kate::TextLine l = kateTextLine(line);
if (!l) {
return false;
}
// nothing to do, do nothing!
if (s.isEmpty()) {
return true;
}
editStart();
QString s2 = s;
int col2 = col;
if (col2 > l->length()) {
s2 = QString(col2 - l->length(), QLatin1Char(' ')) + s;
col2 = l->length();
}
m_undoManager->slotTextInserted(line, col2, s2);
// insert text into line
m_buffer->insertText(KTextEditor::Cursor(line, col2), s2);
emit textInserted(this, KTextEditor::Range(line, col2, line, col2 + s2.length()));
editEnd();
return true;
}
bool KTextEditor::DocumentPrivate::editRemoveText(int line, int col, int len)
{
// verbose debug
EDIT_DEBUG << "editRemoveText" << line << col << len;
if (line < 0 || col < 0 || len < 0) {
return false;
}
if (!isReadWrite()) {
return false;
}
Kate::TextLine l = kateTextLine(line);
if (!l) {
return false;
}
// nothing to do, do nothing!
if (len == 0) {
return true;
}
// wrong column
if (col >= l->text().size()) {
return false;
}
// don't try to remove what's not there
len = qMin(len, l->text().size() - col);
editStart();
QString oldText = l->string().mid(col, len);
m_undoManager->slotTextRemoved(line, col, oldText);
// remove text from line
m_buffer->removeText(KTextEditor::Range(KTextEditor::Cursor(line, col), KTextEditor::Cursor(line, col + len)));
emit textRemoved(this, KTextEditor::Range(line, col, line, col + len), oldText);
editEnd();
return true;
}
bool KTextEditor::DocumentPrivate::editMarkLineAutoWrapped(int line, bool autowrapped)
{
// verbose debug
EDIT_DEBUG << "editMarkLineAutoWrapped" << line << autowrapped;
if (line < 0) {
return false;
}
if (!isReadWrite()) {
return false;
}
Kate::TextLine l = kateTextLine(line);
if (!l) {
return false;
}
editStart();
m_undoManager->slotMarkLineAutoWrapped(line, autowrapped);
l->setAutoWrapped(autowrapped);
editEnd();
return true;
}
bool KTextEditor::DocumentPrivate::editWrapLine(int line, int col, bool newLine, bool *newLineAdded)
{
// verbose debug
EDIT_DEBUG << "editWrapLine" << line << col << newLine;
if (line < 0 || col < 0) {
return false;
}
if (!isReadWrite()) {
return false;
}
Kate::TextLine l = kateTextLine(line);
if (!l) {
return false;
}
editStart();
Kate::TextLine nextLine = kateTextLine(line + 1);
const int length = l->length();
m_undoManager->slotLineWrapped(line, col, length - col, (!nextLine || newLine));
if (!nextLine || newLine) {
m_buffer->wrapLine(KTextEditor::Cursor(line, col));
QList list;
for (QHash::const_iterator i = m_marks.constBegin(); i != m_marks.constEnd(); ++i) {
if (i.value()->line >= line) {
if ((col == 0) || (i.value()->line > line)) {
list.append(i.value());
}
}
}
for (int i = 0; i < list.size(); ++i) {
m_marks.take(list.at(i)->line);
}
for (int i = 0; i < list.size(); ++i) {
list.at(i)->line++;
m_marks.insert(list.at(i)->line, list.at(i));
}
if (!list.isEmpty()) {
emit marksChanged(this);
}
// yes, we added a new line !
if (newLineAdded) {
(*newLineAdded) = true;
}
} else {
m_buffer->wrapLine(KTextEditor::Cursor(line, col));
m_buffer->unwrapLine(line + 2);
// no, no new line added !
if (newLineAdded) {
(*newLineAdded) = false;
}
}
emit textInserted(this, KTextEditor::Range(line, col, line + 1, 0));
editEnd();
return true;
}
bool KTextEditor::DocumentPrivate::editUnWrapLine(int line, bool removeLine, int length)
{
// verbose debug
EDIT_DEBUG << "editUnWrapLine" << line << removeLine << length;
if (line < 0 || length < 0) {
return false;
}
if (!isReadWrite()) {
return false;
}
Kate::TextLine l = kateTextLine(line);
Kate::TextLine nextLine = kateTextLine(line + 1);
if (!l || !nextLine) {
return false;
}
editStart();
int col = l->length();
m_undoManager->slotLineUnWrapped(line, col, length, removeLine);
if (removeLine) {
m_buffer->unwrapLine(line + 1);
} else {
m_buffer->wrapLine(KTextEditor::Cursor(line + 1, length));
m_buffer->unwrapLine(line + 1);
}
QList list;
for (QHash::const_iterator i = m_marks.constBegin(); i != m_marks.constEnd(); ++i) {
if (i.value()->line >= line + 1) {
list.append(i.value());
}
if (i.value()->line == line + 1) {
KTextEditor::Mark *mark = m_marks.take(line);
if (mark) {
i.value()->type |= mark->type;
}
}
}
for (int i = 0; i < list.size(); ++i) {
m_marks.take(list.at(i)->line);
}
for (int i = 0; i < list.size(); ++i) {
list.at(i)->line--;
m_marks.insert(list.at(i)->line, list.at(i));
}
if (!list.isEmpty()) {
emit marksChanged(this);
}
emit textRemoved(this, KTextEditor::Range(line, col, line + 1, 0), QStringLiteral("\n"));
editEnd();
return true;
}
bool KTextEditor::DocumentPrivate::editInsertLine(int line, const QString &s)
{
// verbose debug
EDIT_DEBUG << "editInsertLine" << line << s;
if (line < 0) {
return false;
}
if (!isReadWrite()) {
return false;
}
if (line > lines()) {
return false;
}
editStart();
m_undoManager->slotLineInserted(line, s);
// wrap line
if (line > 0) {
Kate::TextLine previousLine = m_buffer->line(line - 1);
m_buffer->wrapLine(KTextEditor::Cursor(line - 1, previousLine->text().size()));
} else {
m_buffer->wrapLine(KTextEditor::Cursor(0, 0));
}
// insert text
m_buffer->insertText(KTextEditor::Cursor(line, 0), s);
Kate::TextLine tl = m_buffer->line(line);
QList list;
for (QHash::const_iterator i = m_marks.constBegin(); i != m_marks.constEnd(); ++i) {
if (i.value()->line >= line) {
list.append(i.value());
}
}
for (int i = 0; i < list.size(); ++i) {
m_marks.take(list.at(i)->line);
}
for (int i = 0; i < list.size(); ++i) {
list.at(i)->line++;
m_marks.insert(list.at(i)->line, list.at(i));
}
if (!list.isEmpty()) {
emit marksChanged(this);
}
KTextEditor::Range rangeInserted(line, 0, line, tl->length());
if (line) {
Kate::TextLine prevLine = plainKateTextLine(line - 1);
rangeInserted.setStart(KTextEditor::Cursor(line - 1, prevLine->length()));
} else {
rangeInserted.setEnd(KTextEditor::Cursor(line + 1, 0));
}
emit textInserted(this, rangeInserted);
editEnd();
return true;
}
bool KTextEditor::DocumentPrivate::editRemoveLine(int line)
{
return editRemoveLines(line, line);
}
bool KTextEditor::DocumentPrivate::editRemoveLines(int from, int to)
{
// verbose debug
EDIT_DEBUG << "editRemoveLines" << from << to;
if (to < from || from < 0 || to > lastLine()) {
return false;
}
if (!isReadWrite()) {
return false;
}
if (lines() == 1) {
return editRemoveText(0, 0, kateTextLine(0)->length());
}
editStart();
QStringList oldText;
/**
* first remove text
*/
for (int line = to; line >= from; --line) {
Kate::TextLine tl = m_buffer->line(line);
oldText.prepend(this->line(line));
m_undoManager->slotLineRemoved(line, this->line(line));
m_buffer->removeText(KTextEditor::Range(KTextEditor::Cursor(line, 0), KTextEditor::Cursor(line, tl->text().size())));
}
/**
* then collapse lines
*/
for (int line = to; line >= from; --line) {
/**
* unwrap all lines, prefer to unwrap line behind, skip to wrap line 0
*/
if (line + 1 < m_buffer->lines()) {
m_buffer->unwrapLine(line + 1);
} else if (line) {
m_buffer->unwrapLine(line);
}
}
QList rmark;
QList list;
foreach (KTextEditor::Mark *mark, m_marks) {
int line = mark->line;
if (line > to) {
list << line;
} else if (line >= from) {
rmark << line;
}
}
foreach (int line, rmark) {
delete m_marks.take(line);
}
foreach (int line, list) {
KTextEditor::Mark *mark = m_marks.take(line);
mark->line -= to - from + 1;
m_marks.insert(mark->line, mark);
}
if (!list.isEmpty()) {
emit marksChanged(this);
}
KTextEditor::Range rangeRemoved(from, 0, to + 1, 0);
if (to == lastLine() + to - from + 1) {
rangeRemoved.setEnd(KTextEditor::Cursor(to, oldText.last().length()));
if (from > 0) {
Kate::TextLine prevLine = plainKateTextLine(from - 1);
rangeRemoved.setStart(KTextEditor::Cursor(from - 1, prevLine->length()));
}
}
emit textRemoved(this, rangeRemoved, oldText.join(QStringLiteral("\n")) + QLatin1Char('\n'));
editEnd();
return true;
}
//END
//BEGIN KTextEditor::UndoInterface stuff
uint KTextEditor::DocumentPrivate::undoCount() const
{
return m_undoManager->undoCount();
}
uint KTextEditor::DocumentPrivate::redoCount() const
{
return m_undoManager->redoCount();
}
void KTextEditor::DocumentPrivate::undo()
{
m_undoManager->undo();
}
void KTextEditor::DocumentPrivate::redo()
{
m_undoManager->redo();
}
//END
//BEGIN KTextEditor::SearchInterface stuff
QVector KTextEditor::DocumentPrivate::searchText(
const KTextEditor::Range &range,
const QString &pattern,
const KTextEditor::SearchOptions options) const
{
const bool escapeSequences = options.testFlag(KTextEditor::EscapeSequences);
const bool regexMode = options.testFlag(KTextEditor::Regex);
const bool backwards = options.testFlag(KTextEditor::Backwards);
const bool wholeWords = options.testFlag(KTextEditor::WholeWords);
const Qt::CaseSensitivity caseSensitivity = options.testFlag(KTextEditor::CaseInsensitive) ? Qt::CaseInsensitive : Qt::CaseSensitive;
if (regexMode) {
// regexp search
// escape sequences are supported by definition
KateRegExpSearch searcher(this, caseSensitivity);
return searcher.search(pattern, range, backwards);
}
if (escapeSequences) {
// escaped search
KatePlainTextSearch searcher(this, caseSensitivity, wholeWords);
KTextEditor::Range match = searcher.search(KateRegExpSearch::escapePlaintext(pattern), range, backwards);
QVector result;
result.append(match);
return result;
}
// plaintext search
KatePlainTextSearch searcher(this, caseSensitivity, wholeWords);
KTextEditor::Range match = searcher.search(pattern, range, backwards);
QVector result;
result.append(match);
return result;
}
//END
QWidget *KTextEditor::DocumentPrivate::dialogParent()
{
QWidget *w = widget();
if (!w) {
w = activeView();
if (!w) {
w = QApplication::activeWindow();
}
}
return w;
}
//BEGIN KTextEditor::HighlightingInterface stuff
bool KTextEditor::DocumentPrivate::setMode(const QString &name)
{
updateFileType(name);
return true;
}
KTextEditor::DefaultStyle KTextEditor::DocumentPrivate::defaultStyleAt(const KTextEditor::Cursor &position) const
{
// TODO, FIXME KDE5: in surrogate, use 2 bytes before
if (! isValidTextPosition(position)) {
return dsNormal;
}
int ds = const_cast(this)->
defStyleNum(position.line(), position.column());
if (ds < 0 || ds > static_cast(dsError)) {
return dsNormal;
}
return static_cast(ds);
}
QString KTextEditor::DocumentPrivate::mode() const
{
return m_fileType;
}
QStringList KTextEditor::DocumentPrivate::modes() const
{
QStringList m;
const QList &modeList = KTextEditor::EditorPrivate::self()->modeManager()->list();
foreach (KateFileType *type, modeList) {
m << type->name;
}
return m;
}
bool KTextEditor::DocumentPrivate::setHighlightingMode(const QString &name)
{
int mode = KateHlManager::self()->nameFind(name);
if (mode == -1) {
return false;
}
m_buffer->setHighlight(mode);
return true;
}
QString KTextEditor::DocumentPrivate::highlightingMode() const
{
return highlight()->name();
}
QStringList KTextEditor::DocumentPrivate::highlightingModes() const
{
QStringList hls;
-
- for (int i = 0; i < KateHlManager::self()->highlights(); ++i) {
- hls << KateHlManager::self()->hlName(i);
+ for (const auto &hl : KateHlManager::self()->modeList()) {
+ hls << hl.name();
}
-
return hls;
}
QString KTextEditor::DocumentPrivate::highlightingModeSection(int index) const
{
- return KateHlManager::self()->hlSection(index);
+ return KateHlManager::self()->modeList().at(index).section();
}
QString KTextEditor::DocumentPrivate::modeSection(int index) const
{
return KTextEditor::EditorPrivate::self()->modeManager()->list().at(index)->section;
}
void KTextEditor::DocumentPrivate::bufferHlChanged()
{
// update all views
makeAttribs(false);
// deactivate indenter if necessary
m_indenter->checkRequiredStyle();
emit highlightingModeChanged(this);
}
void KTextEditor::DocumentPrivate::setDontChangeHlOnSave()
{
m_hlSetByUser = true;
}
void KTextEditor::DocumentPrivate::bomSetByUser()
{
m_bomSetByUser = true;
}
//END
//BEGIN KTextEditor::SessionConfigInterface and KTextEditor::ParameterizedSessionConfigInterface stuff
void KTextEditor::DocumentPrivate::readSessionConfig(const KConfigGroup &kconfig, const QSet &flags)
{
if (!flags.contains(QStringLiteral("SkipEncoding"))) {
// get the encoding
QString tmpenc = kconfig.readEntry("Encoding");
if (!tmpenc.isEmpty() && (tmpenc != encoding())) {
setEncoding(tmpenc);
}
}
if (!flags.contains(QStringLiteral("SkipUrl"))) {
// restore the url
QUrl url(kconfig.readEntry("URL"));
// open the file if url valid
if (!url.isEmpty() && url.isValid()) {
openUrl(url);
} else {
completed(); //perhaps this should be emitted at the end of this function
}
} else {
completed(); //perhaps this should be emitted at the end of this function
}
if (!flags.contains(QStringLiteral("SkipMode"))) {
// restore the filetype
if (kconfig.hasKey("Mode")) {
updateFileType(kconfig.readEntry("Mode", fileType()));
// restore if set by user, too!
m_fileTypeSetByUser = kconfig.readEntry("Mode Set By User", false);
}
}
if (!flags.contains(QStringLiteral("SkipHighlighting"))) {
// restore the hl stuff
if (kconfig.hasKey("Highlighting")) {
const int mode = KateHlManager::self()->nameFind(kconfig.readEntry("Highlighting"));
if (mode >= 0) {
m_buffer->setHighlight(mode);
// restore if set by user, too! see bug 332605, otherwise we loose the hl later again on save
m_hlSetByUser = kconfig.readEntry("Highlighting Set By User", false);
}
}
}
// indent mode
config()->setIndentationMode(kconfig.readEntry("Indentation Mode", config()->indentationMode()));
// Restore Bookmarks
const QList marks = kconfig.readEntry("Bookmarks", QList());
for (int i = 0; i < marks.count(); i++) {
addMark(marks.at(i), KTextEditor::DocumentPrivate::markType01);
}
}
void KTextEditor::DocumentPrivate::writeSessionConfig(KConfigGroup &kconfig, const QSet &flags)
{
if (this->url().isLocalFile()) {
const QString path = this->url().toLocalFile();
if (path.startsWith(QDir::tempPath())) {
return; // inside tmp resource, do not save
}
}
if (!flags.contains(QStringLiteral("SkipUrl"))) {
// save url
kconfig.writeEntry("URL", this->url().toString());
}
if (!flags.contains(QStringLiteral("SkipEncoding"))) {
// save encoding
kconfig.writeEntry("Encoding", encoding());
}
if (!flags.contains(QStringLiteral("SkipMode"))) {
// save file type
kconfig.writeEntry("Mode", m_fileType);
// save if set by user, too!
kconfig.writeEntry("Mode Set By User", m_fileTypeSetByUser);
}
if (!flags.contains(QStringLiteral("SkipHighlighting"))) {
// save hl
kconfig.writeEntry("Highlighting", highlight()->name());
// save if set by user, too! see bug 332605, otherwise we loose the hl later again on save
kconfig.writeEntry("Highlighting Set By User", m_hlSetByUser);
}
// indent mode
kconfig.writeEntry("Indentation Mode", config()->indentationMode());
// Save Bookmarks
QList marks;
for (QHash::const_iterator i = m_marks.constBegin(); i != m_marks.constEnd(); ++i)
if (i.value()->type & KTextEditor::MarkInterface::markType01) {
marks << i.value()->line;
}
kconfig.writeEntry("Bookmarks", marks);
}
//END KTextEditor::SessionConfigInterface and KTextEditor::ParameterizedSessionConfigInterface stuff
uint KTextEditor::DocumentPrivate::mark(int line)
{
KTextEditor::Mark *m = m_marks.value(line);
if (!m) {
return 0;
}
return m->type;
}
void KTextEditor::DocumentPrivate::setMark(int line, uint markType)
{
clearMark(line);
addMark(line, markType);
}
void KTextEditor::DocumentPrivate::clearMark(int line)
{
if (line < 0 || line > lastLine()) {
return;
}
if (!m_marks.value(line)) {
return;
}
KTextEditor::Mark *mark = m_marks.take(line);
emit markChanged(this, *mark, MarkRemoved);
emit marksChanged(this);
delete mark;
tagLines(line, line);
repaintViews(true);
}
void KTextEditor::DocumentPrivate::addMark(int line, uint markType)
{
KTextEditor::Mark *mark;
if (line < 0 || line > lastLine()) {
return;
}
if (markType == 0) {
return;
}
if ((mark = m_marks.value(line))) {
// Remove bits already set
markType &= ~mark->type;
if (markType == 0) {
return;
}
// Add bits
mark->type |= markType;
} else {
mark = new KTextEditor::Mark;
mark->line = line;
mark->type = markType;
m_marks.insert(line, mark);
}
// Emit with a mark having only the types added.
KTextEditor::Mark temp;
temp.line = line;
temp.type = markType;
emit markChanged(this, temp, MarkAdded);
emit marksChanged(this);
tagLines(line, line);
repaintViews(true);
}
void KTextEditor::DocumentPrivate::removeMark(int line, uint markType)
{
if (line < 0 || line > lastLine()) {
return;
}
KTextEditor::Mark *mark = m_marks.value(line);
if (!mark) {
return;
}
// Remove bits not set
markType &= mark->type;
if (markType == 0) {
return;
}
// Subtract bits
mark->type &= ~markType;
// Emit with a mark having only the types removed.
KTextEditor::Mark temp;
temp.line = line;
temp.type = markType;
emit markChanged(this, temp, MarkRemoved);
if (mark->type == 0) {
m_marks.remove(line);
delete mark;
}
emit marksChanged(this);
tagLines(line, line);
repaintViews(true);
}
const QHash &KTextEditor::DocumentPrivate::marks()
{
return m_marks;
}
void KTextEditor::DocumentPrivate::requestMarkTooltip(int line, QPoint position)
{
KTextEditor::Mark *mark = m_marks.value(line);
if (!mark) {
return;
}
bool handled = false;
emit markToolTipRequested(this, *mark, position, handled);
}
bool KTextEditor::DocumentPrivate::handleMarkClick(int line)
{
bool handled = false;
KTextEditor::Mark *mark = m_marks.value(line);
if (!mark) {
emit markClicked(this, KTextEditor::Mark{line, 0}, handled);
} else {
emit markClicked(this, *mark, handled);
}
return handled;
}
bool KTextEditor::DocumentPrivate::handleMarkContextMenu(int line, QPoint position)
{
bool handled = false;
KTextEditor::Mark *mark = m_marks.value(line);
if (!mark) {
emit markContextMenuRequested(this, KTextEditor::Mark{line, 0}, position, handled);
} else {
emit markContextMenuRequested(this, *mark, position, handled);
}
return handled;
}
void KTextEditor::DocumentPrivate::clearMarks()
{
while (!m_marks.isEmpty()) {
QHash::iterator it = m_marks.begin();
KTextEditor::Mark mark = *it.value();
delete it.value();
m_marks.erase(it);
emit markChanged(this, mark, MarkRemoved);
tagLines(mark.line, mark.line);
}
m_marks.clear();
emit marksChanged(this);
repaintViews(true);
}
void KTextEditor::DocumentPrivate::setMarkPixmap(MarkInterface::MarkTypes type, const QPixmap &pixmap)
{
m_markPixmaps.insert(type, pixmap);
}
void KTextEditor::DocumentPrivate::setMarkDescription(MarkInterface::MarkTypes type, const QString &description)
{
m_markDescriptions.insert(type, description);
}
QPixmap KTextEditor::DocumentPrivate::markPixmap(MarkInterface::MarkTypes type) const
{
return m_markPixmaps.value(type, QPixmap());
}
QColor KTextEditor::DocumentPrivate::markColor(MarkInterface::MarkTypes type) const
{
uint reserved = (0x1 << KTextEditor::MarkInterface::reservedMarkersCount()) - 1;
if ((uint)type >= (uint)markType01 && (uint)type <= reserved) {
return KateRendererConfig::global()->lineMarkerColor(type);
} else {
return QColor();
}
}
QString KTextEditor::DocumentPrivate::markDescription(MarkInterface::MarkTypes type) const
{
return m_markDescriptions.value(type, QString());
}
void KTextEditor::DocumentPrivate::setEditableMarks(uint markMask)
{
m_editableMarks = markMask;
}
uint KTextEditor::DocumentPrivate::editableMarks() const
{
return m_editableMarks;
}
//END
//BEGIN KTextEditor::PrintInterface stuff
bool KTextEditor::DocumentPrivate::print()
{
return KatePrinter::print(this);
}
void KTextEditor::DocumentPrivate::printPreview()
{
KatePrinter::printPreview(this);
}
//END KTextEditor::PrintInterface stuff
//BEGIN KTextEditor::DocumentInfoInterface (### unfinished)
QString KTextEditor::DocumentPrivate::mimeType()
{
/**
* collect first 4k of text
* only heuristic
*/
QByteArray buf;
for (int i = 0; (i < lines()) && (buf.size() <= 4096); ++i) {
buf.append(line(i).toUtf8());
buf.append('\n');
}
// use path of url, too, if set
if (!url().path().isEmpty()) {
return QMimeDatabase().mimeTypeForFileNameAndData(url().path(), buf).name();
}
// else only use the content
return QMimeDatabase().mimeTypeForData(buf).name();
}
//END KTextEditor::DocumentInfoInterface
//BEGIN: error
void KTextEditor::DocumentPrivate::showAndSetOpeningErrorAccess()
{
QPointer message
= new KTextEditor::Message(i18n("The file %1 could not be loaded, as it was not possible to read from it.
Check if you have read access to this file.", this->url().toDisplayString(QUrl::PreferLocalFile)),
KTextEditor::Message::Error);
message->setWordWrap(true);
QAction *tryAgainAction = new QAction(QIcon::fromTheme(QStringLiteral("view-refresh")), i18nc("translators: you can also translate 'Try Again' with 'Reload'", "Try Again"), nullptr);
connect(tryAgainAction, SIGNAL(triggered()), SLOT(documentReload()), Qt::QueuedConnection);
QAction *closeAction = new QAction(QIcon::fromTheme(QStringLiteral("window-close")), i18n("&Close"), nullptr);
closeAction->setToolTip(i18n("Close message"));
// add try again and close actions
message->addAction(tryAgainAction);
message->addAction(closeAction);
// finally post message
postMessage(message);
// remember error
m_openingError = true;
m_openingErrorMessage = i18n("The file %1 could not be loaded, as it was not possible to read from it.\n\nCheck if you have read access to this file.", this->url().toDisplayString(QUrl::PreferLocalFile));
}
//END: error
#ifdef Q_OS_ANDROID
int log2(double d) {
int result;
std::frexp(d, &result);
return result-1;
}
#endif
void KTextEditor::DocumentPrivate::openWithLineLengthLimitOverride()
{
// raise line length limit to the next power of 2
const int longestLine = m_buffer->longestLineLoaded();
int newLimit = pow(2, ceil(log2(longestLine)));
if (newLimit <= longestLine) {
newLimit *= 2;
}
// do the raise
config()->setLineLengthLimit(newLimit);
// just reload
m_buffer->clear();
openFile();
if (!m_openingError) {
setReadWrite(true);
m_readWriteStateBeforeLoading = true;
}
}
int KTextEditor::DocumentPrivate::lineLengthLimit() const
{
return config()->lineLengthLimit();
}
//BEGIN KParts::ReadWrite stuff
bool KTextEditor::DocumentPrivate::openFile()
{
/**
* we are about to invalidate all cursors/ranges/.. => m_buffer->openFile will do so
*/
emit aboutToInvalidateMovingInterfaceContent(this);
// no open errors until now...
m_openingError = false;
m_openingErrorMessage.clear ();
// add new m_file to dirwatch
activateDirWatch();
// remember current encoding
QString currentEncoding = encoding();
//
// mime type magic to get encoding right
//
QString mimeType = arguments().mimeType();
int pos = mimeType.indexOf(QLatin1Char(';'));
if (pos != -1 && !(m_reloading && m_userSetEncodingForNextReload)) {
setEncoding(mimeType.mid(pos + 1));
}
// update file type, we do this here PRE-LOAD, therefore pass file name for reading from
updateFileType(KTextEditor::EditorPrivate::self()->modeManager()->fileType(this, localFilePath()));
// read dir config (if possible and wanted)
// do this PRE-LOAD to get encoding info!
readDirConfig();
// perhaps we need to re-set again the user encoding
if (m_reloading && m_userSetEncodingForNextReload && (currentEncoding != encoding())) {
setEncoding(currentEncoding);
}
bool success = m_buffer->openFile(localFilePath(), (m_reloading && m_userSetEncodingForNextReload));
//
// yeah, success
// read variables
//
if (success) {
readVariables();
}
//
// update views
//
foreach (KTextEditor::ViewPrivate *view, m_views) {
// This is needed here because inserting the text moves the view's start position (it is a MovingCursor)
view->setCursorPosition(KTextEditor::Cursor());
view->updateView(true);
}
// Inform that the text has changed (required as we're not inside the usual editStart/End stuff)
emit textChanged(this);
emit loaded(this);
//
// to houston, we are not modified
//
if (m_modOnHd) {
m_modOnHd = false;
m_modOnHdReason = OnDiskUnmodified;
m_prevModOnHdReason = OnDiskUnmodified;
emit modifiedOnDisk(this, m_modOnHd, m_modOnHdReason);
}
//
// display errors
//
if (!success) {
showAndSetOpeningErrorAccess();
}
// warn: broken encoding
if (m_buffer->brokenEncoding()) {
// this file can't be saved again without killing it
setReadWrite(false);
m_readWriteStateBeforeLoading=false;
QPointer message
= new KTextEditor::Message(i18n("The file %1 was opened with %2 encoding but contained invalid characters.
"
"It is set to read-only mode, as saving might destroy its content.
"
"Either reopen the file with the correct encoding chosen or enable the read-write mode again in the tools menu to be able to edit it.", this->url().toDisplayString(QUrl::PreferLocalFile),
QString::fromLatin1(m_buffer->textCodec()->name())),
KTextEditor::Message::Warning);
message->setWordWrap(true);
postMessage(message);
// remember error
m_openingError = true;
m_openingErrorMessage = i18n("The file %1 was opened with %2 encoding but contained invalid characters."
" It is set to read-only mode, as saving might destroy its content."
" Either reopen the file with the correct encoding chosen or enable the read-write mode again in the tools menu to be able to edit it.", this->url().toDisplayString(QUrl::PreferLocalFile), QString::fromLatin1(m_buffer->textCodec()->name()));
}
// warn: too long lines
if (m_buffer->tooLongLinesWrapped()) {
// this file can't be saved again without modifications
setReadWrite(false);
m_readWriteStateBeforeLoading = false;
QPointer message
= new KTextEditor::Message(i18n("The file %1 was opened and contained lines longer than the configured Line Length Limit (%2 characters).
"
"The longest of those lines was %3 characters long
"
"Those lines were wrapped and the document is set to read-only mode, as saving will modify its content.",
this->url().toDisplayString(QUrl::PreferLocalFile), config()->lineLengthLimit(), m_buffer->longestLineLoaded()),
KTextEditor::Message::Warning);
QAction *increaseAndReload = new QAction(i18n("Temporarily raise limit and reload file"), message);
connect(increaseAndReload, SIGNAL(triggered()), this, SLOT(openWithLineLengthLimitOverride()));
message->addAction(increaseAndReload, true);
message->addAction(new QAction(i18n("Close"), message), true);
message->setWordWrap(true);
postMessage(message);
// remember error
m_openingError = true;
m_openingErrorMessage = i18n("The file %1 was opened and contained lines longer than the configured Line Length Limit (%2 characters).
"
"The longest of those lines was %3 characters long
"
"Those lines were wrapped and the document is set to read-only mode, as saving will modify its content.", this->url().toDisplayString(QUrl::PreferLocalFile), config()->lineLengthLimit(),m_buffer->longestLineLoaded());
}
//
// return the success
//
return success;
}
bool KTextEditor::DocumentPrivate::saveFile()
{
// delete pending mod-on-hd message if applicable.
delete m_modOnHdHandler;
// some warnings, if file was changed by the outside!
if (!url().isEmpty()) {
if (m_fileChangedDialogsActivated && m_modOnHd) {
QString str = reasonedMOHString() + QLatin1String("\n\n");
if (!isModified()) {
if (KMessageBox::warningContinueCancel(dialogParent(),
str + i18n("Do you really want to save this unmodified file? You could overwrite changed data in the file on disk."), i18n("Trying to Save Unmodified File"), KGuiItem(i18n("Save Nevertheless"))) != KMessageBox::Continue) {
return false;
}
} else {
if (KMessageBox::warningContinueCancel(dialogParent(),
str + i18n("Do you really want to save this file? Both your open file and the file on disk were changed. There could be some data lost."), i18n("Possible Data Loss"), KGuiItem(i18n("Save Nevertheless"))) != KMessageBox::Continue) {
return false;
}
}
}
}
//
// can we encode it if we want to save it ?
//
if (!m_buffer->canEncode()
&& (KMessageBox::warningContinueCancel(dialogParent(),
i18n("The selected encoding cannot encode every Unicode character in this document. Do you really want to save it? There could be some data lost."), i18n("Possible Data Loss"), KGuiItem(i18n("Save Nevertheless"))) != KMessageBox::Continue)) {
return false;
}
/**
* create a backup file or abort if that fails!
* if no backup file wanted, this routine will just return true
*/
if (!createBackupFile())
return false;
// update file type, pass no file path, read file type content from this document
QString oldPath = m_dirWatchFile;
// only update file type if path has changed so that variables are not overridden on normal save
if (oldPath != localFilePath()) {
updateFileType(KTextEditor::EditorPrivate::self()->modeManager()->fileType(this, QString()));
if (url().isLocalFile()) {
// if file is local then read dir config for new path
readDirConfig();
}
}
// read our vars
readVariables();
// remove file from dirwatch
deactivateDirWatch();
// remove all trailing spaces in the document (as edit actions)
// NOTE: we need this as edit actions, since otherwise the edit actions
// in the swap file recovery may happen at invalid cursor positions
removeTrailingSpaces();
//
// try to save
//
if (!m_buffer->saveFile(localFilePath())) {
// add m_file again to dirwatch
activateDirWatch(oldPath);
KMessageBox::error(dialogParent(), i18n("The document could not be saved, as it was not possible to write to %1.\n\nCheck that you have write access to this file or that enough disk space is available.", this->url().toDisplayString(QUrl::PreferLocalFile)));
return false;
}
// update the checksum
createDigest();
// add m_file again to dirwatch
activateDirWatch();
//
// we are not modified
//
if (m_modOnHd) {
m_modOnHd = false;
m_modOnHdReason = OnDiskUnmodified;
m_prevModOnHdReason = OnDiskUnmodified;
emit modifiedOnDisk(this, m_modOnHd, m_modOnHdReason);
}
// (dominik) mark last undo group as not mergeable, otherwise the next
// edit action might be merged and undo will never stop at the saved state
m_undoManager->undoSafePoint();
m_undoManager->updateLineModifications();
//
// return success
//
return true;
}
bool KTextEditor::DocumentPrivate::createBackupFile()
{
/**
* backup for local or remote files wanted?
*/
const bool backupLocalFiles = (config()->backupFlags() & KateDocumentConfig::LocalFiles);
const bool backupRemoteFiles = (config()->backupFlags() & KateDocumentConfig::RemoteFiles);
/**
* early out, before mount check: backup wanted at all?
* => if not, all fine, just return
*/
if (!backupLocalFiles && !backupRemoteFiles) {
return true;
}
/**
* decide if we need backup based on locality
* skip that, if we always want backups, as currentMountPoints is not that fast
*/
QUrl u(url());
bool needBackup = backupLocalFiles && backupRemoteFiles;
if (!needBackup) {
bool slowOrRemoteFile = !u.isLocalFile();
if (!slowOrRemoteFile) {
// could be a mounted remote filesystem (e.g. nfs, sshfs, cifs)
// we have the early out above to skip this, if we want no backup, which is the default
KMountPoint::Ptr mountPoint = KMountPoint::currentMountPoints().findByDevice(u.toLocalFile());
slowOrRemoteFile = (mountPoint && mountPoint->probablySlow());
}
needBackup = (!slowOrRemoteFile && backupLocalFiles) || (slowOrRemoteFile && backupRemoteFiles);
}
/**
* no backup needed? be done
*/
if (!needBackup) {
return true;
}
/**
* else: try to backup
*/
if (config()->backupPrefix().contains(QDir::separator())) {
/**
* replace complete path, as prefix is a path!
*/
u.setPath(config()->backupPrefix() + u.fileName() + config()->backupSuffix());
} else {
/**
* replace filename in url
*/
const QString fileName = u.fileName();
u = u.adjusted(QUrl::RemoveFilename);
u.setPath(u.path() + config()->backupPrefix() + fileName + config()->backupSuffix());
}
qCDebug(LOG_KTE) << "backup src file name: " << url();
qCDebug(LOG_KTE) << "backup dst file name: " << u;
// handle the backup...
bool backupSuccess = false;
// local file mode, no kio
if (u.isLocalFile()) {
if (QFile::exists(url().toLocalFile())) {
// first: check if backupFile is already there, if true, unlink it
QFile backupFile(u.toLocalFile());
if (backupFile.exists()) {
backupFile.remove();
}
backupSuccess = QFile::copy(url().toLocalFile(), u.toLocalFile());
} else {
backupSuccess = true;
}
} else { // remote file mode, kio
// get the right permissions, start with safe default
KIO::StatJob *statJob = KIO::stat(url(), KIO::StatJob::SourceSide, 2);
KJobWidgets::setWindow(statJob, QApplication::activeWindow());
if (statJob->exec()) {
// do a evil copy which will overwrite target if possible
KFileItem item(statJob->statResult(), url());
KIO::FileCopyJob *job = KIO::file_copy(url(), u, item.permissions(), KIO::Overwrite);
KJobWidgets::setWindow(job, QApplication::activeWindow());
backupSuccess = job->exec();
} else {
backupSuccess = true;
}
}
// backup has failed, ask user how to proceed
if (!backupSuccess && (KMessageBox::warningContinueCancel(dialogParent()
, i18n("For file %1 no backup copy could be created before saving."
" If an error occurs while saving, you might lose the data of this file."
" A reason could be that the media you write to is full or the directory of the file is read-only for you.", url().toDisplayString(QUrl::PreferLocalFile))
, i18n("Failed to create backup copy.")
, KGuiItem(i18n("Try to Save Nevertheless"))
, KStandardGuiItem::cancel(), QStringLiteral("Backup Failed Warning")) != KMessageBox::Continue)) {
return false;
}
return true;
}
void KTextEditor::DocumentPrivate::readDirConfig()
{
if (!url().isLocalFile()) {
return;
}
/**
* first search .kateconfig upwards
* with recursion guard
*/
QSet seenDirectories;
QDir dir (QFileInfo(localFilePath()).absolutePath());
while (!seenDirectories.contains (dir.absolutePath ())) {
/**
* fill recursion guard
*/
seenDirectories.insert (dir.absolutePath ());
// try to open config file in this dir
QFile f(dir.absolutePath () + QLatin1String("/.kateconfig"));
if (f.open(QIODevice::ReadOnly)) {
QTextStream stream(&f);
uint linesRead = 0;
QString line = stream.readLine();
while ((linesRead < 32) && !line.isNull()) {
readVariableLine(line);
line = stream.readLine();
linesRead++;
}
return;
}
/**
* else: cd up, if possible or abort
*/
if (!dir.cdUp()) {
break;
}
}
#if EDITORCONFIG_FOUND
// if there wasn’t any .kateconfig file and KTextEditor was compiled with
// EditorConfig support, try to load document config from a .editorconfig
// file, if such is provided
EditorConfig editorConfig(this);
editorConfig.parse();
#endif
}
void KTextEditor::DocumentPrivate::activateDirWatch(const QString &useFileName)
{
QString fileToUse = useFileName;
if (fileToUse.isEmpty()) {
fileToUse = localFilePath();
}
QFileInfo fileInfo = QFileInfo(fileToUse);
if (fileInfo.isSymLink()) {
// Monitor the actual data and not the symlink
fileToUse = fileInfo.canonicalFilePath();
}
// same file as we are monitoring, return
if (fileToUse == m_dirWatchFile) {
return;
}
// remove the old watched file
deactivateDirWatch();
// add new file if needed
if (url().isLocalFile() && !fileToUse.isEmpty()) {
KTextEditor::EditorPrivate::self()->dirWatch()->addFile(fileToUse);
m_dirWatchFile = fileToUse;
}
}
void KTextEditor::DocumentPrivate::deactivateDirWatch()
{
if (!m_dirWatchFile.isEmpty()) {
KTextEditor::EditorPrivate::self()->dirWatch()->removeFile(m_dirWatchFile);
}
m_dirWatchFile.clear();
}
bool KTextEditor::DocumentPrivate::openUrl(const QUrl &url)
{
if (!m_reloading) {
// Reset filetype when opening url
m_fileTypeSetByUser = false;
}
bool res = KTextEditor::Document::openUrl(normalizeUrl(url));
updateDocName();
return res;
}
bool KTextEditor::DocumentPrivate::closeUrl()
{
//
// file mod on hd
//
if (!m_reloading && !url().isEmpty()) {
if (m_fileChangedDialogsActivated && m_modOnHd) {
// make sure to not forget pending mod-on-hd handler
delete m_modOnHdHandler;
QWidget *parentWidget(dialogParent());
if (!(KMessageBox::warningContinueCancel(
parentWidget,
reasonedMOHString() + QLatin1String("\n\n") + i18n("Do you really want to continue to close this file? Data loss may occur."),
i18n("Possible Data Loss"), KGuiItem(i18n("Close Nevertheless")), KStandardGuiItem::cancel(),
QStringLiteral("kate_close_modonhd_%1").arg(m_modOnHdReason)) == KMessageBox::Continue)) {
/**
* reset reloading
*/
m_reloading = false;
return false;
}
}
}
//
// first call the normal kparts implementation
//
if (!KParts::ReadWritePart::closeUrl()) {
/**
* reset reloading
*/
m_reloading = false;
return false;
}
// Tell the world that we're about to go ahead with the close
if (!m_reloading) {
emit aboutToClose(this);
}
/**
* delete all KTE::Messages
*/
if (!m_messageHash.isEmpty()) {
QList keys = m_messageHash.keys();
foreach (KTextEditor::Message *message, keys) {
delete message;
}
}
/**
* we are about to invalidate all cursors/ranges/.. => m_buffer->clear will do so
*/
emit aboutToInvalidateMovingInterfaceContent(this);
// remove file from dirwatch
deactivateDirWatch();
//
// empty url + fileName
//
setUrl(QUrl());
setLocalFilePath(QString());
// we are not modified
if (m_modOnHd) {
m_modOnHd = false;
m_modOnHdReason = OnDiskUnmodified;
m_prevModOnHdReason = OnDiskUnmodified;
emit modifiedOnDisk(this, m_modOnHd, m_modOnHdReason);
}
// remove all marks
clearMarks();
// clear the buffer
m_buffer->clear();
// clear undo/redo history
m_undoManager->clearUndo();
m_undoManager->clearRedo();
// no, we are no longer modified
setModified(false);
// we have no longer any hl
m_buffer->setHighlight(0);
// update all our views
foreach (KTextEditor::ViewPrivate *view, m_views) {
view->clearSelection(); // fix bug #118588
view->clear();
}
// purge swap file
if (m_swapfile) {
m_swapfile->fileClosed();
}
// success
return true;
}
bool KTextEditor::DocumentPrivate::isDataRecoveryAvailable() const
{
return m_swapfile && m_swapfile->shouldRecover();
}
void KTextEditor::DocumentPrivate::recoverData()
{
if (isDataRecoveryAvailable()) {
m_swapfile->recover();
}
}
void KTextEditor::DocumentPrivate::discardDataRecovery()
{
if (isDataRecoveryAvailable()) {
m_swapfile->discard();
}
}
void KTextEditor::DocumentPrivate::setReadWrite(bool rw)
{
if (isReadWrite() == rw) {
return;
}
KParts::ReadWritePart::setReadWrite(rw);
foreach (KTextEditor::ViewPrivate *view, m_views) {
view->slotUpdateUndo();
view->slotReadWriteChanged();
}
emit readWriteChanged(this);
}
void KTextEditor::DocumentPrivate::setModified(bool m)
{
if (isModified() != m) {
KParts::ReadWritePart::setModified(m);
foreach (KTextEditor::ViewPrivate *view, m_views) {
view->slotUpdateUndo();
}
emit modifiedChanged(this);
}
m_undoManager->setModified(m);
}
//END
//BEGIN Kate specific stuff ;)
void KTextEditor::DocumentPrivate::makeAttribs(bool needInvalidate)
{
foreach (KTextEditor::ViewPrivate *view, m_views) {
view->renderer()->updateAttributes();
}
if (needInvalidate) {
m_buffer->invalidateHighlighting();
}
foreach (KTextEditor::ViewPrivate *view, m_views) {
view->tagAll();
view->updateView(true);
}
}
// the attributes of a hl have changed, update
void KTextEditor::DocumentPrivate::internalHlChanged()
{
makeAttribs();
}
void KTextEditor::DocumentPrivate::addView(KTextEditor::View *view)
{
Q_ASSERT (!m_views.contains(view));
m_views.insert(view, static_cast(view));
m_viewsCache.append(view);
// apply the view & renderer vars from the file type
if (!m_fileType.isEmpty()) {
readVariableLine(KTextEditor::EditorPrivate::self()->modeManager()->fileType(m_fileType).varLine, true);
}
// apply the view & renderer vars from the file
readVariables(true);
setActiveView(view);
}
void KTextEditor::DocumentPrivate::removeView(KTextEditor::View *view)
{
Q_ASSERT (m_views.contains(view));
m_views.remove(view);
m_viewsCache.removeAll(view);
if (activeView() == view) {
setActiveView(nullptr);
}
}
void KTextEditor::DocumentPrivate::setActiveView(KTextEditor::View *view)
{
if (m_activeView == view) {
return;
}
m_activeView = static_cast(view);
}
bool KTextEditor::DocumentPrivate::ownedView(KTextEditor::ViewPrivate *view)
{
// do we own the given view?
return (m_views.contains(view));
}
int KTextEditor::DocumentPrivate::toVirtualColumn(int line, int column) const
{
Kate::TextLine textLine = m_buffer->plainLine(line);
if (textLine) {
return textLine->toVirtualColumn(column, config()->tabWidth());
} else {
return 0;
}
}
int KTextEditor::DocumentPrivate::toVirtualColumn(const KTextEditor::Cursor &cursor) const
{
return toVirtualColumn(cursor.line(), cursor.column());
}
int KTextEditor::DocumentPrivate::fromVirtualColumn(int line, int column) const
{
Kate::TextLine textLine = m_buffer->plainLine(line);
if (textLine) {
return textLine->fromVirtualColumn(column, config()->tabWidth());
} else {
return 0;
}
}
int KTextEditor::DocumentPrivate::fromVirtualColumn(const KTextEditor::Cursor &cursor) const
{
return fromVirtualColumn(cursor.line(), cursor.column());
}
bool KTextEditor::DocumentPrivate::typeChars(KTextEditor::ViewPrivate *view, const QString &realChars)
{
/**
* filter out non-printable chars (convert to utf-32 to support surrogate pairs)
*/
const auto realUcs4Chars = realChars.toUcs4();
QVector ucs4Chars;
Q_FOREACH (auto c, realUcs4Chars)
if (QChar::isPrint(c) || c == QChar::fromLatin1('\t') || c == QChar::fromLatin1('\n') || c == QChar::fromLatin1('\r')) {
ucs4Chars.append(c);
}
QString chars = QString::fromUcs4(ucs4Chars.data(), ucs4Chars.size());
/**
* no printable chars => nothing to insert!
*/
if (chars.isEmpty()) {
return false;
}
/**
* auto bracket handling for newly inserted text
* remember if we should auto add some
*/
QChar closingBracket;
if (view->config()->autoBrackets() && chars.size() == 1) {
/**
* we inserted a bracket?
* => remember the matching closing one
*/
closingBracket = matchingEndBracket(chars[0], true);
/**
* closing bracket for the autobracket we inserted earlier?
*/
if ( m_currentAutobraceClosingChar == chars[0] && m_currentAutobraceRange ) {
// do nothing
m_currentAutobraceRange.reset(nullptr);
view->cursorRight();
return true;
}
}
/**
* selection around => special handling if we want to add auto brackets
*/
if (view->selection() && !closingBracket.isNull()) {
/**
* add bracket at start + end of the selection
*/
KTextEditor::Cursor oldCur = view->cursorPosition();
insertText(view->selectionRange().start(), chars);
view->slotTextInserted(view, oldCur, chars);
view->setCursorPosition(view->selectionRange().end());
oldCur = view->cursorPosition();
insertText(view->selectionRange().end(), QString(closingBracket));
view->slotTextInserted(view, oldCur, QString(closingBracket));
/**
* expand selection
*/
view->setSelection(KTextEditor::Range(view->selectionRange().start() + Cursor{0, 1},
view->cursorPosition() - Cursor{0, 1}));
view->setCursorPosition(view->selectionRange().start());
}
/**
* else normal handling
*/
else {
editStart();
if (!view->config()->persistentSelection() && view->selection()) {
view->removeSelectedText();
}
const KTextEditor::Cursor oldCur(view->cursorPosition());
const bool multiLineBlockMode = view->blockSelection() && view->selection();
if (view->currentInputMode()->overwrite()) {
// blockmode multiline selection case: remove chars in every line
const KTextEditor::Range selectionRange = view->selectionRange();
const int startLine = multiLineBlockMode ? qMax(0, selectionRange.start().line()) : view->cursorPosition().line();
const int endLine = multiLineBlockMode ? qMin(selectionRange.end().line(), lastLine()) : startLine;
const int virtualColumn = toVirtualColumn(multiLineBlockMode ? selectionRange.end() : view->cursorPosition());
for (int line = endLine; line >= startLine; --line) {
Kate::TextLine textLine = m_buffer->plainLine(line);
Q_ASSERT(textLine);
const int column = fromVirtualColumn(line, virtualColumn);
KTextEditor::Range r = KTextEditor::Range(KTextEditor::Cursor(line, column), qMin(chars.length(),
textLine->length() - column));
// replace mode needs to know what was removed so it can be restored with backspace
if (oldCur.column() < lineLength(line)) {
QChar removed = characterAt(KTextEditor::Cursor(line, column));
view->currentInputMode()->overwrittenChar(removed);
}
removeText(r);
}
}
if (multiLineBlockMode) {
KTextEditor::Range selectionRange = view->selectionRange();
const int startLine = qMax(0, selectionRange.start().line());
const int endLine = qMin(selectionRange.end().line(), lastLine());
const int column = toVirtualColumn(selectionRange.end());
for (int line = endLine; line >= startLine; --line) {
editInsertText(line, fromVirtualColumn(line, column), chars);
}
int newSelectionColumn = toVirtualColumn(view->cursorPosition());
selectionRange.setRange(KTextEditor::Cursor(selectionRange.start().line(), fromVirtualColumn(selectionRange.start().line(), newSelectionColumn))
, KTextEditor::Cursor(selectionRange.end().line(), fromVirtualColumn(selectionRange.end().line(), newSelectionColumn)));
view->setSelection(selectionRange);
} else {
chars = eventuallyReplaceTabs(view->cursorPosition(), chars);
insertText(view->cursorPosition(), chars);
}
/**
* auto bracket handling for newly inserted text
* we inserted a bracket?
* => add the matching closing one to the view + input chars
* try to preserve the cursor position
*/
bool skipAutobrace = closingBracket == QLatin1Char('\'');
if ( highlight() && skipAutobrace ) {
// skip adding ' in spellchecked areas, because those are text
skipAutobrace = highlight()->spellCheckingRequiredForLocation(this, view->cursorPosition() - Cursor{0, 1});
}
if (!closingBracket.isNull() && !skipAutobrace ) {
// add bracket to the view
const auto cursorPos(view->cursorPosition());
const auto nextChar = view->document()->text({cursorPos, cursorPos + Cursor{0, 1}}).trimmed();
if ( nextChar.isEmpty() || ! nextChar.at(0).isLetterOrNumber() ) {
insertText(view->cursorPosition(), QString(closingBracket));
const auto insertedAt(view->cursorPosition());
view->setCursorPosition(cursorPos);
m_currentAutobraceRange.reset(newMovingRange({cursorPos - Cursor{0, 1}, insertedAt},
KTextEditor::MovingRange::DoNotExpand));
connect(view, &View::cursorPositionChanged,
this, &DocumentPrivate::checkCursorForAutobrace, Qt::UniqueConnection);
// add bracket to chars inserted! needed for correct signals + indent
chars.append(closingBracket);
}
m_currentAutobraceClosingChar = closingBracket;
}
// end edit session here, to have updated HL in userTypedChar!
editEnd();
// trigger indentation
KTextEditor::Cursor b(view->cursorPosition());
m_indenter->userTypedChar(view, b, chars.isEmpty() ? QChar() : chars.at(chars.length() - 1));
/**
* inform the view about the original inserted chars
*/
view->slotTextInserted(view, oldCur, chars);
}
/**
* be done
*/
return true;
}
void KTextEditor::DocumentPrivate::checkCursorForAutobrace(KTextEditor::View*, const KTextEditor::Cursor& newPos) {
if ( m_currentAutobraceRange && ! m_currentAutobraceRange->toRange().contains(newPos) ) {
m_currentAutobraceRange.clear();
}
}
void KTextEditor::DocumentPrivate::newLine(KTextEditor::ViewPrivate *v)
{
editStart();
if (!v->config()->persistentSelection() && v->selection()) {
v->removeSelectedText();
v->clearSelection();
}
// query cursor position
KTextEditor::Cursor c = v->cursorPosition();
if (c.line() > lastLine()) {
c.setLine(lastLine());
}
if (c.line() < 0) {
c.setLine(0);
}
int ln = c.line();
Kate::TextLine textLine = plainKateTextLine(ln);
if (c.column() > textLine->length()) {
c.setColumn(textLine->length());
}
// first: wrap line
editWrapLine(c.line(), c.column());
// end edit session here, to have updated HL in userTypedChar!
editEnd();
// second: indent the new line, if needed...
m_indenter->userTypedChar(v, v->cursorPosition(), QLatin1Char('\n'));
}
void KTextEditor::DocumentPrivate::transpose(const KTextEditor::Cursor &cursor)
{
Kate::TextLine textLine = m_buffer->plainLine(cursor.line());
if (!textLine || (textLine->length() < 2)) {
return;
}
uint col = cursor.column();
if (col > 0) {
col--;
}
if ((textLine->length() - col) < 2) {
return;
}
uint line = cursor.line();
QString s;
//clever swap code if first character on the line swap right&left
//otherwise left & right
s.append(textLine->at(col + 1));
s.append(textLine->at(col));
//do the swap
// do it right, never ever manipulate a textline
editStart();
editRemoveText(line, col, 2);
editInsertText(line, col, s);
editEnd();
}
void KTextEditor::DocumentPrivate::backspace(KTextEditor::ViewPrivate *view, const KTextEditor::Cursor &c)
{
if (!view->config()->persistentSelection() && view->selection()) {
if (view->blockSelection() && view->selection() && toVirtualColumn(view->selectionRange().start()) == toVirtualColumn(view->selectionRange().end())) {
// Remove one character after selection line
KTextEditor::Range range = view->selectionRange();
range.setStart(KTextEditor::Cursor(range.start().line(), range.start().column() - 1));
view->setSelection(range);
}
view->removeSelectedText();
return;
}
uint col = qMax(c.column(), 0);
uint line = qMax(c.line(), 0);
if ((col == 0) && (line == 0)) {
return;
}
if (col > 0) {
bool useNextBlock = false;
if (config()->backspaceIndents()) {
// backspace indents: erase to next indent position
Kate::TextLine textLine = m_buffer->plainLine(line);
// don't forget this check!!!! really!!!!
if (!textLine) {
return;
}
int colX = textLine->toVirtualColumn(col, config()->tabWidth());
int pos = textLine->firstChar();
if (pos > 0) {
pos = textLine->toVirtualColumn(pos, config()->tabWidth());
}
if (pos < 0 || pos >= (int)colX) {
// only spaces on left side of cursor
indent(KTextEditor::Range(line, 0, line, 0), -1);
}
else {
useNextBlock = true;
}
}
if (!config()->backspaceIndents() || useNextBlock) {
KTextEditor::Cursor beginCursor(line, 0);
KTextEditor::Cursor endCursor(line, col);
if (!view->config()->backspaceRemoveComposed()) { // Normal backspace behavior
beginCursor.setColumn(col - 1);
// move to left of surrogate pair
if (!isValidTextPosition(beginCursor)) {
Q_ASSERT(col >= 2);
beginCursor.setColumn(col - 2);
}
} else {
beginCursor.setColumn(view->textLayout(c)->previousCursorPosition(c.column()));
}
removeText(KTextEditor::Range(beginCursor, endCursor));
// in most cases cursor is moved by removeText, but we should do it manually
// for past-end-of-line cursors in block mode
view->setCursorPosition(beginCursor);
}
} else {
// col == 0: wrap to previous line
if (line >= 1) {
Kate::TextLine textLine = m_buffer->plainLine(line - 1);
// don't forget this check!!!! really!!!!
if (!textLine) {
return;
}
if (config()->wordWrap() && textLine->endsWith(QLatin1String(" "))) {
// gg: in hard wordwrap mode, backspace must also eat the trailing space
removeText(KTextEditor::Range(line - 1, textLine->length() - 1, line, 0));
} else {
removeText(KTextEditor::Range(line - 1, textLine->length(), line, 0));
}
}
}
if ( m_currentAutobraceRange ) {
const auto r = m_currentAutobraceRange->toRange();
if ( r.columnWidth() == 1 && view->cursorPosition() == r.start() ) {
// start parenthesis removed and range length is 1, remove end as well
del(view, view->cursorPosition());
m_currentAutobraceRange.clear();
}
}
}
void KTextEditor::DocumentPrivate::del(KTextEditor::ViewPrivate *view, const KTextEditor::Cursor &c)
{
if (!view->config()->persistentSelection() && view->selection()) {
if (view->blockSelection() && view->selection() && toVirtualColumn(view->selectionRange().start()) == toVirtualColumn(view->selectionRange().end())) {
// Remove one character after selection line
KTextEditor::Range range = view->selectionRange();
range.setEnd(KTextEditor::Cursor(range.end().line(), range.end().column() + 1));
view->setSelection(range);
}
view->removeSelectedText();
return;
}
if (c.column() < (int) m_buffer->plainLine(c.line())->length()) {
KTextEditor::Cursor endCursor(c.line(), view->textLayout(c)->nextCursorPosition(c.column()));
removeText(KTextEditor::Range(c, endCursor));
} else if (c.line() < lastLine()) {
removeText(KTextEditor::Range(c.line(), c.column(), c.line() + 1, 0));
}
}
void KTextEditor::DocumentPrivate::paste(KTextEditor::ViewPrivate *view, const QString &text)
{
static const QChar newLineChar(QLatin1Char('\n'));
QString s = text;
if (s.isEmpty()) {
return;
}
int lines = s.count(newLineChar);
m_undoManager->undoSafePoint();
editStart();
KTextEditor::Cursor pos = view->cursorPosition();
if (!view->config()->persistentSelection() && view->selection()) {
pos = view->selectionRange().start();
if (view->blockSelection()) {
pos = rangeOnLine(view->selectionRange(), pos.line()).start();
if (lines == 0) {
s += newLineChar;
s = s.repeated(view->selectionRange().numberOfLines() + 1);
s.chop(1);
}
}
view->removeSelectedText();
}
if (config()->ovr()) {
QStringList pasteLines = s.split(newLineChar);
if (!view->blockSelection()) {
int endColumn = (pasteLines.count() == 1 ? pos.column() : 0) + pasteLines.last().length();
removeText(KTextEditor::Range(pos,
pos.line() + pasteLines.count() - 1, endColumn));
} else {
int maxi = qMin(pos.line() + pasteLines.count(), this->lines());
for (int i = pos.line(); i < maxi; ++i) {
int pasteLength = pasteLines.at(i - pos.line()).length();
removeText(KTextEditor::Range(i, pos.column(),
i, qMin(pasteLength + pos.column(), lineLength(i))));
}
}
}
insertText(pos, s, view->blockSelection());
editEnd();
// move cursor right for block select, as the user is moved right internal
// even in that case, but user expects other behavior in block selection
// mode !
// just let cursor stay, that was it before I changed to moving ranges!
if (view->blockSelection()) {
view->setCursorPositionInternal(pos);
}
if (config()->indentPastedText()) {
KTextEditor::Range range = KTextEditor::Range(KTextEditor::Cursor(pos.line(), 0),
KTextEditor::Cursor(pos.line() + lines, 0));
m_indenter->indent(view, range);
}
if (!view->blockSelection()) {
emit charactersSemiInteractivelyInserted(pos, s);
}
m_undoManager->undoSafePoint();
}
void KTextEditor::DocumentPrivate::indent(KTextEditor::Range range, int change)
{
if (!isReadWrite()) {
return;
}
editStart();
m_indenter->changeIndent(range, change);
editEnd();
}
void KTextEditor::DocumentPrivate::align(KTextEditor::ViewPrivate *view, const KTextEditor::Range &range)
{
m_indenter->indent(view, range);
}
void KTextEditor::DocumentPrivate::insertTab(KTextEditor::ViewPrivate *view, const KTextEditor::Cursor &)
{
if (!isReadWrite()) {
return;
}
int lineLen = line(view->cursorPosition().line()).length();
KTextEditor::Cursor c = view->cursorPosition();
editStart();
if (!view->config()->persistentSelection() && view->selection()) {
view->removeSelectedText();
} else if (view->currentInputMode()->overwrite() && c.column() < lineLen) {
KTextEditor::Range r = KTextEditor::Range(view->cursorPosition(), 1);
// replace mode needs to know what was removed so it can be restored with backspace
QChar removed = line(view->cursorPosition().line()).at(r.start().column());
view->currentInputMode()->overwrittenChar(removed);
removeText(r);
}
c = view->cursorPosition();
editInsertText(c.line(), c.column(), QStringLiteral("\t"));
editEnd();
}
/*
Remove a given string at the beginning
of the current line.
*/
bool KTextEditor::DocumentPrivate::removeStringFromBeginning(int line, const QString &str)
{
Kate::TextLine textline = m_buffer->plainLine(line);
KTextEditor::Cursor cursor(line, 0);
bool there = textline->startsWith(str);
if (!there) {
cursor.setColumn(textline->firstChar());
there = textline->matchesAt(cursor.column(), str);
}
if (there) {
// Remove some chars
removeText(KTextEditor::Range(cursor, str.length()));
}
return there;
}
/*
Remove a given string at the end
of the current line.
*/
bool KTextEditor::DocumentPrivate::removeStringFromEnd(int line, const QString &str)
{
Kate::TextLine textline = m_buffer->plainLine(line);
KTextEditor::Cursor cursor(line, 0);
bool there = textline->endsWith(str);
if (there) {
cursor.setColumn(textline->length() - str.length());
} else {
cursor.setColumn(textline->lastChar() - str.length() + 1);
there = textline->matchesAt(cursor.column(), str);
}
if (there) {
// Remove some chars
removeText(KTextEditor::Range(cursor, str.length()));
}
return there;
}
/*
Replace tabs by spaces in the given string, if enabled.
*/
QString KTextEditor::DocumentPrivate::eventuallyReplaceTabs(const KTextEditor::Cursor &cursorPos, const QString &str) const
{
const bool replacetabs = config()->replaceTabsDyn();
if ( ! replacetabs ) {
return str;
}
const int indentWidth = config()->indentationWidth();
static const QLatin1Char tabChar('\t');
int column = cursorPos.column();
// The result will always be at least as long as the input
QString result;
result.reserve(str.size());
Q_FOREACH (const QChar ch, str) {
if (ch == tabChar) {
// Insert only enough spaces to align to the next indentWidth column
// This fixes bug #340212
int spacesToInsert = indentWidth - (column % indentWidth);
result += QStringLiteral(" ").repeated(spacesToInsert);
column += spacesToInsert;
} else {
// Just keep all other typed characters as-is
result += ch;
++column;
}
}
return result;
}
/*
Add to the current line a comment line mark at the beginning.
*/
void KTextEditor::DocumentPrivate::addStartLineCommentToSingleLine(int line, int attrib)
{
QString commentLineMark = highlight()->getCommentSingleLineStart(attrib);
int pos = -1;
if (highlight()->getCommentSingleLinePosition(attrib) == KSyntaxHighlighting::CommentPosition::StartOfLine) {
pos = 0;
commentLineMark += QLatin1Char(' ');
} else {
const Kate::TextLine l = kateTextLine(line);
pos = l->firstChar();
}
if (pos >= 0) {
insertText(KTextEditor::Cursor(line, pos), commentLineMark);
}
}
/*
Remove from the current line a comment line mark at
the beginning if there is one.
*/
bool KTextEditor::DocumentPrivate::removeStartLineCommentFromSingleLine(int line, int attrib)
{
const QString shortCommentMark = highlight()->getCommentSingleLineStart(attrib);
const QString longCommentMark = shortCommentMark + QLatin1Char(' ');
editStart();
// Try to remove the long comment mark first
bool removed = (removeStringFromBeginning(line, longCommentMark)
|| removeStringFromBeginning(line, shortCommentMark));
editEnd();
return removed;
}
/*
Add to the current line a start comment mark at the
beginning and a stop comment mark at the end.
*/
void KTextEditor::DocumentPrivate::addStartStopCommentToSingleLine(int line, int attrib)
{
const QString startCommentMark = highlight()->getCommentStart(attrib) + QLatin1Char(' ');
const QString stopCommentMark = QLatin1Char(' ') + highlight()->getCommentEnd(attrib);
editStart();
// Add the start comment mark
insertText(KTextEditor::Cursor(line, 0), startCommentMark);
// Go to the end of the line
const int col = m_buffer->plainLine(line)->length();
// Add the stop comment mark
insertText(KTextEditor::Cursor(line, col), stopCommentMark);
editEnd();
}
/*
Remove from the current line a start comment mark at
the beginning and a stop comment mark at the end.
*/
bool KTextEditor::DocumentPrivate::removeStartStopCommentFromSingleLine(int line, int attrib)
{
const QString shortStartCommentMark = highlight()->getCommentStart(attrib);
const QString longStartCommentMark = shortStartCommentMark + QLatin1Char(' ');
const QString shortStopCommentMark = highlight()->getCommentEnd(attrib);
const QString longStopCommentMark = QLatin1Char(' ') + shortStopCommentMark;
editStart();
// Try to remove the long start comment mark first
const bool removedStart = (removeStringFromBeginning(line, longStartCommentMark)
|| removeStringFromBeginning(line, shortStartCommentMark));
// Try to remove the long stop comment mark first
const bool removedStop = removedStart
&& (removeStringFromEnd(line, longStopCommentMark) || removeStringFromEnd(line, shortStopCommentMark));
editEnd();
return (removedStart || removedStop);
}
/*
Add to the current selection a start comment mark at the beginning
and a stop comment mark at the end.
*/
void KTextEditor::DocumentPrivate::addStartStopCommentToSelection(KTextEditor::ViewPrivate *view, int attrib)
{
const QString startComment = highlight()->getCommentStart(attrib);
const QString endComment = highlight()->getCommentEnd(attrib);
KTextEditor::Range range = view->selectionRange();
if ((range.end().column() == 0) && (range.end().line() > 0)) {
range.setEnd(KTextEditor::Cursor(range.end().line() - 1, lineLength(range.end().line() - 1)));
}
editStart();
if (!view->blockSelection()) {
insertText(range.end(), endComment);
insertText(range.start(), startComment);
} else {
for (int line = range.start().line(); line <= range.end().line(); line++) {
KTextEditor::Range subRange = rangeOnLine(range, line);
insertText(subRange.end(), endComment);
insertText(subRange.start(), startComment);
}
}
editEnd();
// selection automatically updated (MovingRange)
}
/*
Add to the current selection a comment line mark at the beginning of each line.
*/
void KTextEditor::DocumentPrivate::addStartLineCommentToSelection(KTextEditor::ViewPrivate *view, int attrib)
{
const QString commentLineMark = highlight()->getCommentSingleLineStart(attrib) + QLatin1Char(' ');
int sl = view->selectionRange().start().line();
int el = view->selectionRange().end().line();
// if end of selection is in column 0 in last line, omit the last line
if ((view->selectionRange().end().column() == 0) && (el > 0)) {
el--;
}
editStart();
// For each line of the selection
for (int z = el; z >= sl; z--) {
//insertText (z, 0, commentLineMark);
addStartLineCommentToSingleLine(z, attrib);
}
editEnd();
// selection automatically updated (MovingRange)
}
bool KTextEditor::DocumentPrivate::nextNonSpaceCharPos(int &line, int &col)
{
for (; line < (int)m_buffer->count(); line++) {
Kate::TextLine textLine = m_buffer->plainLine(line);
if (!textLine) {
break;
}
col = textLine->nextNonSpaceChar(col);
if (col != -1) {
return true; // Next non-space char found
}
col = 0;
}
// No non-space char found
line = -1;
col = -1;
return false;
}
bool KTextEditor::DocumentPrivate::previousNonSpaceCharPos(int &line, int &col)
{
while (true) {
Kate::TextLine textLine = m_buffer->plainLine(line);
if (!textLine) {
break;
}
col = textLine->previousNonSpaceChar(col);
if (col != -1) {
return true;
}
if (line == 0) {
return false;
}
--line;
col = textLine->length();
}
// No non-space char found
line = -1;
col = -1;
return false;
}
/*
Remove from the selection a start comment mark at
the beginning and a stop comment mark at the end.
*/
bool KTextEditor::DocumentPrivate::removeStartStopCommentFromSelection(KTextEditor::ViewPrivate *view, int attrib)
{
const QString startComment = highlight()->getCommentStart(attrib);
const QString endComment = highlight()->getCommentEnd(attrib);
int sl = qMax (0, view->selectionRange().start().line());
int el = qMin (view->selectionRange().end().line(), lastLine());
int sc = view->selectionRange().start().column();
int ec = view->selectionRange().end().column();
// The selection ends on the char before selectEnd
if (ec != 0) {
--ec;
} else if (el > 0) {
--el;
ec = m_buffer->plainLine(el)->length() - 1;
}
const int startCommentLen = startComment.length();
const int endCommentLen = endComment.length();
// had this been perl or sed: s/^\s*$startComment(.+?)$endComment\s*/$2/
bool remove = nextNonSpaceCharPos(sl, sc)
&& m_buffer->plainLine(sl)->matchesAt(sc, startComment)
&& previousNonSpaceCharPos(el, ec)
&& ((ec - endCommentLen + 1) >= 0)
&& m_buffer->plainLine(el)->matchesAt(ec - endCommentLen + 1, endComment);
if (remove) {
editStart();
removeText(KTextEditor::Range(el, ec - endCommentLen + 1, el, ec + 1));
removeText(KTextEditor::Range(sl, sc, sl, sc + startCommentLen));
editEnd();
// selection automatically updated (MovingRange)
}
return remove;
}
bool KTextEditor::DocumentPrivate::removeStartStopCommentFromRegion(const KTextEditor::Cursor &start, const KTextEditor::Cursor &end, int attrib)
{
const QString startComment = highlight()->getCommentStart(attrib);
const QString endComment = highlight()->getCommentEnd(attrib);
const int startCommentLen = startComment.length();
const int endCommentLen = endComment.length();
const bool remove = m_buffer->plainLine(start.line())->matchesAt(start.column(), startComment)
&& m_buffer->plainLine(end.line())->matchesAt(end.column() - endCommentLen, endComment);
if (remove) {
editStart();
removeText(KTextEditor::Range(end.line(), end.column() - endCommentLen, end.line(), end.column()));
removeText(KTextEditor::Range(start, startCommentLen));
editEnd();
}
return remove;
}
/*
Remove from the beginning of each line of the
selection a start comment line mark.
*/
bool KTextEditor::DocumentPrivate::removeStartLineCommentFromSelection(KTextEditor::ViewPrivate *view, int attrib)
{
const QString shortCommentMark = highlight()->getCommentSingleLineStart(attrib);
const QString longCommentMark = shortCommentMark + QLatin1Char(' ');
int sl = view->selectionRange().start().line();
int el = view->selectionRange().end().line();
if ((view->selectionRange().end().column() == 0) && (el > 0)) {
el--;
}
bool removed = false;
editStart();
// For each line of the selection
for (int z = el; z >= sl; z--) {
// Try to remove the long comment mark first
removed = (removeStringFromBeginning(z, longCommentMark)
|| removeStringFromBeginning(z, shortCommentMark)
|| removed);
}
editEnd();
// selection automatically updated (MovingRange)
return removed;
}
/*
Comment or uncomment the selection or the current
line if there is no selection.
*/
void KTextEditor::DocumentPrivate::comment(KTextEditor::ViewPrivate *v, uint line, uint column, int change)
{
// skip word wrap bug #105373
const bool skipWordWrap = wordWrap();
if (skipWordWrap) {
setWordWrap(false);
}
bool hassel = v->selection();
int c = 0;
if (hassel) {
c = v->selectionRange().start().column();
}
int startAttrib = 0;
Kate::TextLine ln = kateTextLine(line);
if (c < ln->length()) {
startAttrib = ln->attribute(c);
} else if (!ln->attributesList().isEmpty()) {
startAttrib = ln->attributesList().back().attributeValue;
}
bool hasStartLineCommentMark = !(highlight()->getCommentSingleLineStart(startAttrib).isEmpty());
bool hasStartStopCommentMark = (!(highlight()->getCommentStart(startAttrib).isEmpty())
&& !(highlight()->getCommentEnd(startAttrib).isEmpty()));
if (change > 0) { // comment
if (!hassel) {
if (hasStartLineCommentMark) {
addStartLineCommentToSingleLine(line, startAttrib);
} else if (hasStartStopCommentMark) {
addStartStopCommentToSingleLine(line, startAttrib);
}
} else {
// anders: prefer single line comment to avoid nesting probs
// If the selection starts after first char in the first line
// or ends before the last char of the last line, we may use
// multiline comment markers.
// TODO We should try to detect nesting.
// - if selection ends at col 0, most likely she wanted that
// line ignored
const KTextEditor::Range sel = v->selectionRange();
if (hasStartStopCommentMark &&
(!hasStartLineCommentMark || (
(sel.start().column() > m_buffer->plainLine(sel.start().line())->firstChar()) ||
(sel.end().column() > 0 &&
sel.end().column() < (m_buffer->plainLine(sel.end().line())->length()))
))) {
addStartStopCommentToSelection(v, startAttrib);
} else if (hasStartLineCommentMark) {
addStartLineCommentToSelection(v, startAttrib);
}
}
} else { // uncomment
bool removed = false;
if (!hassel) {
removed = (hasStartLineCommentMark
&& removeStartLineCommentFromSingleLine(line, startAttrib))
|| (hasStartStopCommentMark
&& removeStartStopCommentFromSingleLine(line, startAttrib));
} else {
// anders: this seems like it will work with above changes :)
removed = (hasStartStopCommentMark
&& removeStartStopCommentFromSelection(v, startAttrib))
|| (hasStartLineCommentMark
&& removeStartLineCommentFromSelection(v, startAttrib));
}
// recursive call for toggle comment
if (!removed && change == 0) {
comment(v, line, column, 1);
}
}
if (skipWordWrap) {
setWordWrap(true); // see begin of function ::comment (bug #105373)
}
}
void KTextEditor::DocumentPrivate::transform(KTextEditor::ViewPrivate *v, const KTextEditor::Cursor &c,
KTextEditor::DocumentPrivate::TextTransform t)
{
if (v->selection()) {
editStart();
// cache the selection and cursor, so we can be sure to restore.
KTextEditor::Range selection = v->selectionRange();
KTextEditor::Range range(selection.start(), 0);
while (range.start().line() <= selection.end().line()) {
int start = 0;
int end = lineLength(range.start().line());
if (range.start().line() == selection.start().line() || v->blockSelection()) {
start = selection.start().column();
}
if (range.start().line() == selection.end().line() || v->blockSelection()) {
end = selection.end().column();
}
if (start > end) {
int swapCol = start;
start = end;
end = swapCol;
}
range.setStart(KTextEditor::Cursor(range.start().line(), start));
range.setEnd(KTextEditor::Cursor(range.end().line(), end));
QString s = text(range);
QString old = s;
if (t == Uppercase) {
s = s.toUpper();
} else if (t == Lowercase) {
s = s.toLower();
} else { // Capitalize
Kate::TextLine l = m_buffer->plainLine(range.start().line());
int p(0);
while (p < s.length()) {
// If bol or the character before is not in a word, up this one:
// 1. if both start and p is 0, upper char.
// 2. if blockselect or first line, and p == 0 and start-1 is not in a word, upper
// 3. if p-1 is not in a word, upper.
if ((! range.start().column() && ! p) ||
((range.start().line() == selection.start().line() || v->blockSelection()) &&
! p && ! highlight()->isInWord(l->at(range.start().column() - 1))) ||
(p && ! highlight()->isInWord(s.at(p - 1)))
) {
s[p] = s.at(p).toUpper();
}
p++;
}
}
if (s != old) {
removeText(range);
insertText(range.start(), s);
}
range.setBothLines(range.start().line() + 1);
}
editEnd();
// restore selection & cursor
v->setSelection(selection);
v->setCursorPosition(c);
} else { // no selection
editStart();
// get cursor
KTextEditor::Cursor cursor = c;
QString old = text(KTextEditor::Range(cursor, 1));
QString s;
switch (t) {
case Uppercase:
s = old.toUpper();
break;
case Lowercase:
s = old.toLower();
break;
case Capitalize: {
Kate::TextLine l = m_buffer->plainLine(cursor.line());
while (cursor.column() > 0 && highlight()->isInWord(l->at(cursor.column() - 1), l->attribute(cursor.column() - 1))) {
cursor.setColumn(cursor.column() - 1);
}
old = text(KTextEditor::Range(cursor, 1));
s = old.toUpper();
}
break;
default:
break;
}
removeText(KTextEditor::Range(cursor, 1));
insertText(cursor, s);
editEnd();
}
}
void KTextEditor::DocumentPrivate::joinLines(uint first, uint last)
{
// if ( first == last ) last += 1;
editStart();
int line(first);
while (first < last) {
// Normalize the whitespace in the joined lines by making sure there's
// always exactly one space between the joined lines
// This cannot be done in editUnwrapLine, because we do NOT want this
// behavior when deleting from the start of a line, just when explicitly
// calling the join command
Kate::TextLine l = kateTextLine(line);
Kate::TextLine tl = kateTextLine(line + 1);
if (!l || !tl) {
editEnd();
return;
}
int pos = tl->firstChar();
if (pos >= 0) {
if (pos != 0) {
editRemoveText(line + 1, 0, pos);
}
if (!(l->length() == 0 || l->at(l->length() - 1).isSpace())) {
editInsertText(line + 1, 0, QLatin1String(" "));
}
} else {
// Just remove the whitespace and let Kate handle the rest
editRemoveText(line + 1, 0, tl->length());
}
editUnWrapLine(line);
first++;
}
editEnd();
}
void KTextEditor::DocumentPrivate::tagLines(int start, int end)
{
foreach (KTextEditor::ViewPrivate *view, m_views) {
view->tagLines(start, end, true);
}
}
void KTextEditor::DocumentPrivate::repaintViews(bool paintOnlyDirty)
{
foreach (KTextEditor::ViewPrivate *view, m_views) {
view->repaintText(paintOnlyDirty);
}
}
/*
Bracket matching uses the following algorithm:
If in overwrite mode, match the bracket currently underneath the cursor.
Otherwise, if the character to the left is a bracket,
match it. Otherwise if the character to the right of the cursor is a
bracket, match it. Otherwise, don't match anything.
*/
KTextEditor::Range KTextEditor::DocumentPrivate::findMatchingBracket(const KTextEditor::Cursor &start, int maxLines)
{
if (maxLines < 0) {
return KTextEditor::Range::invalid();
}
Kate::TextLine textLine = m_buffer->plainLine(start.line());
if (!textLine) {
return KTextEditor::Range::invalid();
}
KTextEditor::Range range(start, start);
const QChar right = textLine->at(range.start().column());
const QChar left = textLine->at(range.start().column() - 1);
QChar bracket;
if (config()->ovr()) {
if (isBracket(right)) {
bracket = right;
} else {
return KTextEditor::Range::invalid();
}
} else if (isBracket(right)) {
bracket = right;
} else if (isBracket(left)) {
range.setStart(KTextEditor::Cursor(range.start().line(), range.start().column() - 1));
bracket = left;
} else {
return KTextEditor::Range::invalid();
}
const QChar opposite = matchingBracket(bracket, false);
if (opposite.isNull()) {
return KTextEditor::Range::invalid();
}
const int searchDir = isStartBracket(bracket) ? 1 : -1;
uint nesting = 0;
const int minLine = qMax(range.start().line() - maxLines, 0);
const int maxLine = qMin(range.start().line() + maxLines, documentEnd().line());
range.setEnd(range.start());
KTextEditor::DocumentCursor cursor(this);
cursor.setPosition(range.start());
int validAttr = kateTextLine(cursor.line())->attribute(cursor.column());
while (cursor.line() >= minLine && cursor.line() <= maxLine) {
if (!cursor.move(searchDir)) {
return KTextEditor::Range::invalid();
}
Kate::TextLine textLine = kateTextLine(cursor.line());
if (textLine->attribute(cursor.column()) == validAttr) {
// Check for match
QChar c = textLine->at(cursor.column());
if (c == opposite) {
if (nesting == 0) {
if (searchDir > 0) { // forward
range.setEnd(cursor.toCursor());
} else {
range.setStart(cursor.toCursor());
}
return range;
}
nesting--;
} else if (c == bracket) {
nesting++;
}
}
}
return KTextEditor::Range::invalid();
}
// helper: remove \r and \n from visible document name (bug #170876)
inline static QString removeNewLines(const QString &str)
{
QString tmp(str);
return tmp.replace(QLatin1String("\r\n"), QLatin1String(" "))
.replace(QLatin1Char('\r'), QLatin1Char(' '))
.replace(QLatin1Char('\n'), QLatin1Char(' '));
}
void KTextEditor::DocumentPrivate::updateDocName()
{
// if the name is set, and starts with FILENAME, it should not be changed!
if (! url().isEmpty()
&& (m_docName == removeNewLines(url().fileName()) ||
m_docName.startsWith(removeNewLines(url().fileName()) + QLatin1String(" (")))) {
return;
}
int count = -1;
foreach (KTextEditor::DocumentPrivate *doc, KTextEditor::EditorPrivate::self()->kateDocuments()) {
if ((doc != this) && (doc->url().fileName() == url().fileName()))
if (doc->m_docNameNumber > count) {
count = doc->m_docNameNumber;
}
}
m_docNameNumber = count + 1;
QString oldName = m_docName;
m_docName = removeNewLines(url().fileName());
m_isUntitled = m_docName.isEmpty();
if (m_isUntitled) {
m_docName = i18n("Untitled");
}
if (m_docNameNumber > 0) {
m_docName = QString(m_docName + QLatin1String(" (%1)")).arg(m_docNameNumber + 1);
}
/**
* avoid to emit this, if name doesn't change!
*/
if (oldName != m_docName) {
emit documentNameChanged(this);
}
}
void KTextEditor::DocumentPrivate::slotModifiedOnDisk(KTextEditor::View * /*v*/)
{
if (url().isEmpty() || !m_modOnHd) {
return;
}
if (!m_fileChangedDialogsActivated || m_modOnHdHandler) {
return;
}
// don't ask the user again and again the same thing
if (m_modOnHdReason == m_prevModOnHdReason) {
return;
}
m_prevModOnHdReason = m_modOnHdReason;
m_modOnHdHandler = new KateModOnHdPrompt(this, m_modOnHdReason, reasonedMOHString());
connect(m_modOnHdHandler.data(), &KateModOnHdPrompt::saveAsTriggered, this, &DocumentPrivate::onModOnHdSaveAs);
connect(m_modOnHdHandler.data(), &KateModOnHdPrompt::reloadTriggered, this, &DocumentPrivate::onModOnHdReload);
connect(m_modOnHdHandler.data(), &KateModOnHdPrompt::ignoreTriggered, this, &DocumentPrivate::onModOnHdIgnore);
}
void KTextEditor::DocumentPrivate::onModOnHdSaveAs()
{
m_modOnHd = false;
QWidget *parentWidget(dialogParent());
const QUrl res = QFileDialog::getSaveFileUrl(parentWidget, i18n("Save File"), url(), {}, nullptr,
QFileDialog::DontConfirmOverwrite);
if (!res.isEmpty() && checkOverwrite(res, parentWidget)) {
if (! saveAs(res)) {
KMessageBox::error(parentWidget, i18n("Save failed"));
m_modOnHd = true;
} else {
delete m_modOnHdHandler;
m_prevModOnHdReason = OnDiskUnmodified;
emit modifiedOnDisk(this, false, OnDiskUnmodified);
}
} else { // the save as dialog was canceled, we are still modified on disk
m_modOnHd = true;
}
}
void KTextEditor::DocumentPrivate::onModOnHdReload()
{
m_modOnHd = false;
m_prevModOnHdReason = OnDiskUnmodified;
emit modifiedOnDisk(this, false, OnDiskUnmodified);
documentReload();
delete m_modOnHdHandler;
}
void KTextEditor::DocumentPrivate::onModOnHdIgnore()
{
// ignore as long as m_prevModOnHdReason == m_modOnHdReason
delete m_modOnHdHandler;
}
void KTextEditor::DocumentPrivate::setModifiedOnDisk(ModifiedOnDiskReason reason)
{
m_modOnHdReason = reason;
m_modOnHd = (reason != OnDiskUnmodified);
emit modifiedOnDisk(this, (reason != OnDiskUnmodified), reason);
}
class KateDocumentTmpMark
{
public:
QString line;
KTextEditor::Mark mark;
};
void KTextEditor::DocumentPrivate::setModifiedOnDiskWarning(bool on)
{
m_fileChangedDialogsActivated = on;
}
bool KTextEditor::DocumentPrivate::documentReload()
{
if (url().isEmpty()) {
return false;
}
// typically, the message for externally modified files is visible. Since it
// does not make sense showing an additional dialog, just hide the message.
delete m_modOnHdHandler;
if (m_modOnHd && m_fileChangedDialogsActivated) {
QWidget *parentWidget(dialogParent());
int i = KMessageBox::warningYesNoCancel
(parentWidget, reasonedMOHString() + QLatin1String("\n\n") + i18n("What do you want to do?"),
i18n("File Was Changed on Disk"),
KGuiItem(i18n("&Reload File"), QStringLiteral("view-refresh")),
KGuiItem(i18n("&Ignore Changes"), QStringLiteral("dialog-warning")));
if (i != KMessageBox::Yes) {
if (i == KMessageBox::No) {
m_modOnHd = false;
m_modOnHdReason = OnDiskUnmodified;
m_prevModOnHdReason = OnDiskUnmodified;
emit modifiedOnDisk(this, m_modOnHd, m_modOnHdReason);
}
// reset some flags only valid for one reload!
m_userSetEncodingForNextReload = false;
return false;
}
}
emit aboutToReload(this);
QList tmp;
for (QHash::const_iterator i = m_marks.constBegin(); i != m_marks.constEnd(); ++i) {
KateDocumentTmpMark m;
m.line = line(i.value()->line);
m.mark = *i.value();
tmp.append(m);
}
const QString oldMode = mode();
const bool byUser = m_fileTypeSetByUser;
const QString hl_mode = highlightingMode();
m_storedVariables.clear();
// save cursor positions for all views
QHash cursorPositions;
for (auto it = m_views.constBegin(); it != m_views.constEnd(); ++it) {
auto v = it.value();
cursorPositions.insert(v, v->cursorPosition());
}
m_reloading = true;
KTextEditor::DocumentPrivate::openUrl(url());
// reset some flags only valid for one reload!
m_userSetEncodingForNextReload = false;
// restore cursor positions for all views
for (auto it = m_views.constBegin(); it != m_views.constEnd(); ++it) {
auto v = it.value();
setActiveView(v);
v->setCursorPosition(cursorPositions.value(v));
if (v->isVisible()) {
v->repaintText(false);
}
}
for (int z = 0; z < tmp.size(); z++) {
if (z < lines()) {
if (line(tmp.at(z).mark.line) == tmp.at(z).line) {
setMark(tmp.at(z).mark.line, tmp.at(z).mark.type);
}
}
}
if (byUser) {
setMode(oldMode);
}
setHighlightingMode(hl_mode);
emit reloaded(this);
return true;
}
bool KTextEditor::DocumentPrivate::documentSave()
{
if (!url().isValid() || !isReadWrite()) {
return documentSaveAs();
}
return save();
}
bool KTextEditor::DocumentPrivate::documentSaveAs()
{
const QUrl saveUrl = QFileDialog::getSaveFileUrl(dialogParent(), i18n("Save File"), url(), {}, nullptr,
QFileDialog::DontConfirmOverwrite);
if (saveUrl.isEmpty() || !checkOverwrite(saveUrl, dialogParent())) {
return false;
}
return saveAs(saveUrl);
}
bool KTextEditor::DocumentPrivate::documentSaveAsWithEncoding(const QString &encoding)
{
const QUrl saveUrl = QFileDialog::getSaveFileUrl(dialogParent(), i18n("Save File"), url(), {}, nullptr,
QFileDialog::DontConfirmOverwrite);
if (saveUrl.isEmpty() || !checkOverwrite(saveUrl, dialogParent())) {
return false;
}
setEncoding(encoding);
return saveAs(saveUrl);
}
bool KTextEditor::DocumentPrivate::documentSaveCopyAs()
{
const QUrl saveUrl = QFileDialog::getSaveFileUrl(dialogParent(), i18n("Save Copy of File"), url(), {}, nullptr,
QFileDialog::DontConfirmOverwrite);
if (saveUrl.isEmpty() || !checkOverwrite(saveUrl, dialogParent())) {
return false;
}
QTemporaryFile file;
if (!file.open()) {
return false;
}
if (!m_buffer->saveFile(file.fileName())) {
KMessageBox::error(dialogParent(), i18n("The document could not be saved, as it was not possible to write to %1.\n\nCheck that you have write access to this file or that enough disk space is available.", this->url().toDisplayString(QUrl::PreferLocalFile)));
return false;
}
// get the right permissions, start with safe default
KIO::StatJob *statJob = KIO::stat(url(), KIO::StatJob::SourceSide, 2);
KJobWidgets::setWindow(statJob, QApplication::activeWindow());
int permissions = -1;
if (statJob->exec()) {
permissions = KFileItem(statJob->statResult(), url()).permissions();
}
// KIO move, important: allow overwrite, we checked above!
KIO::FileCopyJob *job = KIO::file_copy(QUrl::fromLocalFile(file.fileName()), saveUrl, permissions, KIO::Overwrite);
KJobWidgets::setWindow(job, QApplication::activeWindow());
return job->exec();
}
void KTextEditor::DocumentPrivate::setWordWrap(bool on)
{
config()->setWordWrap(on);
}
bool KTextEditor::DocumentPrivate::wordWrap() const
{
return config()->wordWrap();
}
void KTextEditor::DocumentPrivate::setWordWrapAt(uint col)
{
config()->setWordWrapAt(col);
}
unsigned int KTextEditor::DocumentPrivate::wordWrapAt() const
{
return config()->wordWrapAt();
}
void KTextEditor::DocumentPrivate::setPageUpDownMovesCursor(bool on)
{
config()->setPageUpDownMovesCursor(on);
}
bool KTextEditor::DocumentPrivate::pageUpDownMovesCursor() const
{
return config()->pageUpDownMovesCursor();
}
//END
bool KTextEditor::DocumentPrivate::setEncoding(const QString &e)
{
return m_config->setEncoding(e);
}
QString KTextEditor::DocumentPrivate::encoding() const
{
return m_config->encoding();
}
void KTextEditor::DocumentPrivate::updateConfig()
{
m_undoManager->updateConfig();
// switch indenter if needed and update config....
m_indenter->setMode(m_config->indentationMode());
m_indenter->updateConfig();
// set tab width there, too
m_buffer->setTabWidth(config()->tabWidth());
// update all views, does tagAll and updateView...
foreach (KTextEditor::ViewPrivate *view, m_views) {
view->updateDocumentConfig();
}
// update on-the-fly spell checking as spell checking defaults might have changes
if (m_onTheFlyChecker) {
m_onTheFlyChecker->updateConfig();
}
emit configChanged();
}
//BEGIN Variable reader
// "local variable" feature by anders, 2003
/* TODO
add config options (how many lines to read, on/off)
add interface for plugins/apps to set/get variables
add view stuff
*/
void KTextEditor::DocumentPrivate::readVariables(bool onlyViewAndRenderer)
{
if (!onlyViewAndRenderer) {
m_config->configStart();
}
// views!
KTextEditor::ViewPrivate *v;
foreach (v, m_views) {
v->config()->configStart();
v->renderer()->config()->configStart();
}
// read a number of lines in the top/bottom of the document
for (int i = 0; i < qMin(9, lines()); ++i) {
readVariableLine(line(i), onlyViewAndRenderer);
}
if (lines() > 10) {
for (int i = qMax(10, lines() - 10); i < lines(); i++) {
readVariableLine(line(i), onlyViewAndRenderer);
}
}
if (!onlyViewAndRenderer) {
m_config->configEnd();
}
foreach (v, m_views) {
v->config()->configEnd();
v->renderer()->config()->configEnd();
}
}
void KTextEditor::DocumentPrivate::readVariableLine(QString t, bool onlyViewAndRenderer)
{
static const QRegularExpression kvLine(QStringLiteral("kate:(.*)"));
static const QRegularExpression kvLineWildcard(QStringLiteral("kate-wildcard\\((.*)\\):(.*)"));
static const QRegularExpression kvLineMime(QStringLiteral("kate-mimetype\\((.*)\\):(.*)"));
static const QRegularExpression kvVar(QStringLiteral("([\\w\\-]+)\\s+([^;]+)"));
// simple check first, no regex
// no kate inside, no vars, simple...
if (!t.contains(QLatin1String("kate"))) {
return;
}
// found vars, if any
QString s;
// now, try first the normal ones
auto match = kvLine.match(t);
if (match.hasMatch()) {
s = match.captured(1);
//qCDebug(LOG_KTE) << "normal variable line kate: matched: " << s;
} else if ((match = kvLineWildcard.match(t)).hasMatch()) { // regex given
const QStringList wildcards(match.captured(1).split(QLatin1Char(';'), QString::SkipEmptyParts));
const QString nameOfFile = url().fileName();
bool found = false;
foreach (const QString &pattern, wildcards) {
QRegExp wildcard(pattern, Qt::CaseSensitive, QRegExp::Wildcard);
found = wildcard.exactMatch(nameOfFile);
if (found) {
break;
}
}
// nothing usable found...
if (!found) {
return;
}
s = match.captured(2);
//qCDebug(LOG_KTE) << "guarded variable line kate-wildcard: matched: " << s;
} else if ((match = kvLineMime.match(t)).hasMatch()) { // mime-type given
const QStringList types(match.captured(1).split(QLatin1Char(';'), QString::SkipEmptyParts));
// no matching type found
if (!types.contains(mimeType())) {
return;
}
s = match.captured(2);
//qCDebug(LOG_KTE) << "guarded variable line kate-mimetype: matched: " << s;
} else { // nothing found
return;
}
// view variable names
static const auto vvl = {
QLatin1String("dynamic-word-wrap")
, QLatin1String("dynamic-word-wrap-indicators")
, QLatin1String("line-numbers")
, QLatin1String("icon-border")
, QLatin1String("folding-markers")
, QLatin1String("folding-preview")
, QLatin1String("bookmark-sorting")
, QLatin1String("auto-center-lines")
, QLatin1String("icon-bar-color")
, QLatin1String("scrollbar-minimap")
, QLatin1String("scrollbar-preview")
// renderer
, QLatin1String("background-color")
, QLatin1String("selection-color")
, QLatin1String("current-line-color")
, QLatin1String("bracket-highlight-color")
, QLatin1String("word-wrap-marker-color")
, QLatin1String("font")
, QLatin1String("font-size")
, QLatin1String("scheme")
};
int spaceIndent = -1; // for backward compatibility; see below
bool replaceTabsSet = false;
int startPos(0);
QString var, val;
while ((match = kvVar.match(s, startPos)).hasMatch()) {
startPos = match.capturedEnd(0);
var = match.captured(1);
val = match.captured(2).trimmed();
bool state; // store booleans here
int n; // store ints here
// only apply view & renderer config stuff
if (onlyViewAndRenderer) {
if (contains(vvl, var)) { // FIXME define above
setViewVariable(var, val);
}
} else {
// BOOL SETTINGS
if (var == QLatin1String("word-wrap") && checkBoolValue(val, &state)) {
setWordWrap(state); // ??? FIXME CHECK
}
// KateConfig::configFlags
// FIXME should this be optimized to only a few calls? how?
else if (var == QLatin1String("backspace-indents") && checkBoolValue(val, &state)) {
m_config->setBackspaceIndents(state);
} else if (var == QLatin1String("indent-pasted-text") && checkBoolValue(val, &state)) {
m_config->setIndentPastedText(state);
} else if (var == QLatin1String("replace-tabs") && checkBoolValue(val, &state)) {
m_config->setReplaceTabsDyn(state);
replaceTabsSet = true; // for backward compatibility; see below
} else if (var == QLatin1String("remove-trailing-space") && checkBoolValue(val, &state)) {
qCWarning(LOG_KTE) << i18n("Using deprecated modeline 'remove-trailing-space'. "
"Please replace with 'remove-trailing-spaces modified;', see "
"http://docs.kde.org/stable/en/applications/kate/config-variables.html#variable-remove-trailing-spaces");
m_config->setRemoveSpaces(state ? 1 : 0);
} else if (var == QLatin1String("replace-trailing-space-save") && checkBoolValue(val, &state)) {
qCWarning(LOG_KTE) << i18n("Using deprecated modeline 'replace-trailing-space-save'. "
"Please replace with 'remove-trailing-spaces all;', see "
"http://docs.kde.org/stable/en/applications/kate/config-variables.html#variable-remove-trailing-spaces");
m_config->setRemoveSpaces(state ? 2 : 0);
} else if (var == QLatin1String("overwrite-mode") && checkBoolValue(val, &state)) {
m_config->setOvr(state);
} else if (var == QLatin1String("keep-extra-spaces") && checkBoolValue(val, &state)) {
m_config->setKeepExtraSpaces(state);
} else if (var == QLatin1String("tab-indents") && checkBoolValue(val, &state)) {
m_config->setTabIndents(state);
} else if (var == QLatin1String("show-tabs") && checkBoolValue(val, &state)) {
m_config->setShowTabs(state);
} else if (var == QLatin1String("show-trailing-spaces") && checkBoolValue(val, &state)) {
m_config->setShowSpaces(state);
} else if (var == QLatin1String("space-indent") && checkBoolValue(val, &state)) {
// this is for backward compatibility; see below
spaceIndent = state;
} else if (var == QLatin1String("smart-home") && checkBoolValue(val, &state)) {
m_config->setSmartHome(state);
} else if (var == QLatin1String("newline-at-eof") && checkBoolValue(val, &state)) {
m_config->setNewLineAtEof(state);
}
// INTEGER SETTINGS
else if (var == QLatin1String("tab-width") && checkIntValue(val, &n)) {
m_config->setTabWidth(n);
} else if (var == QLatin1String("indent-width") && checkIntValue(val, &n)) {
m_config->setIndentationWidth(n);
} else if (var == QLatin1String("indent-mode")) {
m_config->setIndentationMode(val);
} else if (var == QLatin1String("word-wrap-column") && checkIntValue(val, &n) && n > 0) { // uint, but hard word wrap at 0 will be no fun ;)
m_config->setWordWrapAt(n);
}
// STRING SETTINGS
else if (var == QLatin1String("eol") || var == QLatin1String("end-of-line")) {
const auto l = { QLatin1String("unix"), QLatin1String("dos"), QLatin1String("mac") };
if ((n = indexOf(l, val.toLower())) != -1) {
/**
* set eol + avoid that it is overwritten by auto-detection again!
* this fixes e.g. .kateconfig files with // kate: eol dos; to work, bug 365705
*/
m_config->setEol(n);
m_config->setAllowEolDetection(false);
}
} else if (var == QLatin1String("bom") || var == QLatin1String("byte-order-mark") || var == QLatin1String("byte-order-marker")) {
if (checkBoolValue(val, &state)) {
m_config->setBom(state);
}
} else if (var == QLatin1String("remove-trailing-spaces")) {
val = val.toLower();
if (val == QLatin1String("1") || val == QLatin1String("modified") || val == QLatin1String("mod") || val == QLatin1String("+")) {
m_config->setRemoveSpaces(1);
} else if (val == QLatin1String("2") || val == QLatin1String("all") || val == QLatin1String("*")) {
m_config->setRemoveSpaces(2);
} else {
m_config->setRemoveSpaces(0);
}
} else if (var == QLatin1String("syntax") || var == QLatin1String("hl")) {
setHighlightingMode(val);
} else if (var == QLatin1String("mode")) {
setMode(val);
} else if (var == QLatin1String("encoding")) {
setEncoding(val);
} else if (var == QLatin1String("default-dictionary")) {
setDefaultDictionary(val);
} else if (var == QLatin1String("automatic-spell-checking") && checkBoolValue(val, &state)) {
onTheFlySpellCheckingEnabled(state);
}
// VIEW SETTINGS
else if (contains(vvl, var)) {
setViewVariable(var, val);
} else {
m_storedVariables.insert(var, val);
}
}
}
// Backward compatibility
// If space-indent was set, but replace-tabs was not set, we assume
// that the user wants to replace tabulators and set that flag.
// If both were set, replace-tabs has precedence.
// At this point spaceIndent is -1 if it was never set,
// 0 if it was set to off, and 1 if it was set to on.
// Note that if onlyViewAndRenderer was requested, spaceIndent is -1.
if (!replaceTabsSet && spaceIndent >= 0) {
m_config->setReplaceTabsDyn(spaceIndent > 0);
}
}
void KTextEditor::DocumentPrivate::setViewVariable(QString var, QString val)
{
KTextEditor::ViewPrivate *v;
bool state;
int n;
QColor c;
foreach (v, m_views) {
if (var == QLatin1String("auto-brackets") && checkBoolValue(val, &state)) {
v->config()->setAutoBrackets(state);
} else if (var == QLatin1String("dynamic-word-wrap") && checkBoolValue(val, &state)) {
v->config()->setDynWordWrap(state);
} else if (var == QLatin1String("persistent-selection") && checkBoolValue(val, &state)) {
v->config()->setPersistentSelection(state);
} else if (var == QLatin1String("block-selection") && checkBoolValue(val, &state)) {
v->setBlockSelection(state);
}
//else if ( var = "dynamic-word-wrap-indicators" )
else if (var == QLatin1String("line-numbers") && checkBoolValue(val, &state)) {
v->config()->setLineNumbers(state);
} else if (var == QLatin1String("icon-border") && checkBoolValue(val, &state)) {
v->config()->setIconBar(state);
} else if (var == QLatin1String("folding-markers") && checkBoolValue(val, &state)) {
v->config()->setFoldingBar(state);
} else if (var == QLatin1String("folding-preview") && checkBoolValue(val, &state)) {
v->config()->setFoldingPreview(state);
} else if (var == QLatin1String("auto-center-lines") && checkIntValue(val, &n)) {
v->config()->setAutoCenterLines(n);
} else if (var == QLatin1String("icon-bar-color") && checkColorValue(val, c)) {
v->renderer()->config()->setIconBarColor(c);
} else if (var == QLatin1String("scrollbar-minimap") && checkBoolValue(val, &state)) {
v->config()->setScrollBarMiniMap(state);
} else if (var == QLatin1String("scrollbar-preview") && checkBoolValue(val, &state)) {
v->config()->setScrollBarPreview(state);
}
// RENDERER
else if (var == QLatin1String("background-color") && checkColorValue(val, c)) {
v->renderer()->config()->setBackgroundColor(c);
} else if (var == QLatin1String("selection-color") && checkColorValue(val, c)) {
v->renderer()->config()->setSelectionColor(c);
} else if (var == QLatin1String("current-line-color") && checkColorValue(val, c)) {
v->renderer()->config()->setHighlightedLineColor(c);
} else if (var == QLatin1String("bracket-highlight-color") && checkColorValue(val, c)) {
v->renderer()->config()->setHighlightedBracketColor(c);
} else if (var == QLatin1String("word-wrap-marker-color") && checkColorValue(val, c)) {
v->renderer()->config()->setWordWrapMarkerColor(c);
} else if (var == QLatin1String("font") || (checkIntValue(val, &n) && var == QLatin1String("font-size"))) {
QFont _f(v->renderer()->config()->font());
if (var == QLatin1String("font")) {
_f.setFamily(val);
_f.setFixedPitch(QFont(val).fixedPitch());
} else {
_f.setPointSize(n);
}
v->renderer()->config()->setFont(_f);
} else if (var == QLatin1String("scheme")) {
v->renderer()->config()->setSchema(val);
}
}
}
bool KTextEditor::DocumentPrivate::checkBoolValue(QString val, bool *result)
{
val = val.trimmed().toLower();
static const auto trueValues = { QLatin1String("1"), QLatin1String("on"), QLatin1String("true") };
if (contains(trueValues, val)) {
*result = true;
return true;
}
static const auto falseValues = { QLatin1String("0"), QLatin1String("off"), QLatin1String("false") };
if (contains(falseValues, val)) {
*result = false;
return true;
}
return false;
}
bool KTextEditor::DocumentPrivate::checkIntValue(QString val, int *result)
{
bool ret(false);
*result = val.toInt(&ret);
return ret;
}
bool KTextEditor::DocumentPrivate::checkColorValue(QString val, QColor &c)
{
c.setNamedColor(val);
return c.isValid();
}
// KTextEditor::variable
QString KTextEditor::DocumentPrivate::variable(const QString &name) const
{
return m_storedVariables.value(name, QString());
}
void KTextEditor::DocumentPrivate::setVariable(const QString &name, const QString &value)
{
QString s = QStringLiteral("kate: ");
s.append(name);
s.append(QLatin1Char(' '));
s.append(value);
readVariableLine(s);
}
//END
void KTextEditor::DocumentPrivate::slotModOnHdDirty(const QString &path)
{
if ((path == m_dirWatchFile) && (!m_modOnHd || m_modOnHdReason != OnDiskModified)) {
m_modOnHd = true;
m_modOnHdReason = OnDiskModified;
if (!m_modOnHdTimer.isActive()) {
m_modOnHdTimer.start();
}
}
}
void KTextEditor::DocumentPrivate::slotModOnHdCreated(const QString &path)
{
if ((path == m_dirWatchFile) && (!m_modOnHd || m_modOnHdReason != OnDiskCreated)) {
m_modOnHd = true;
m_modOnHdReason = OnDiskCreated;
if (!m_modOnHdTimer.isActive()) {
m_modOnHdTimer.start();
}
}
}
void KTextEditor::DocumentPrivate::slotModOnHdDeleted(const QString &path)
{
if ((path == m_dirWatchFile) && (!m_modOnHd || m_modOnHdReason != OnDiskDeleted)) {
m_modOnHd = true;
m_modOnHdReason = OnDiskDeleted;
if (!m_modOnHdTimer.isActive()) {
m_modOnHdTimer.start();
}
}
}
void KTextEditor::DocumentPrivate::slotDelayedHandleModOnHd()
{
// compare git hash with the one we have (if we have one)
const QByteArray oldDigest = checksum();
if (!oldDigest.isEmpty() && !url().isEmpty() && url().isLocalFile()) {
/**
* if current checksum == checksum of new file => unmodified
*/
if (m_modOnHdReason != OnDiskDeleted && createDigest() && oldDigest == checksum()) {
m_modOnHd = false;
m_modOnHdReason = OnDiskUnmodified;
m_prevModOnHdReason = OnDiskUnmodified;
}
#if LIBGIT2_FOUND
/**
* if still modified, try to take a look at git
* skip that, if document is modified!
* only do that, if the file is still there, else reload makes no sense!
*/
if (m_modOnHd && !isModified() && QFile::exists(url().toLocalFile())) {
/**
* try to discover the git repo of this file
* libgit2 docs state that UTF-8 is the right encoding, even on windows
* I hope that is correct!
*/
git_repository *repository = nullptr;
const QByteArray utf8Path = url().toLocalFile().toUtf8();
if (git_repository_open_ext(&repository, utf8Path.constData(), 0, nullptr) == 0) {
/**
* if we have repo, convert the git hash to an OID
*/
git_oid oid;
if (git_oid_fromstr(&oid, oldDigest.toHex().data()) == 0) {
/**
* finally: is there a blob for this git hash?
*/
git_blob *blob = nullptr;
if (git_blob_lookup(&blob, repository, &oid) == 0) {
/**
* this hash exists still in git => just reload
*/
m_modOnHd = false;
m_modOnHdReason = OnDiskUnmodified;
m_prevModOnHdReason = OnDiskUnmodified;
documentReload();
}
git_blob_free(blob);
}
}
git_repository_free(repository);
}
#endif
}
/**
* emit our signal to the outside!
*/
emit modifiedOnDisk(this, m_modOnHd, m_modOnHdReason);
}
QByteArray KTextEditor::DocumentPrivate::checksum() const
{
return m_buffer->digest();
}
bool KTextEditor::DocumentPrivate::createDigest()
{
QByteArray digest;
if (url().isLocalFile()) {
QFile f(url().toLocalFile());
if (f.open(QIODevice::ReadOnly)) {
// init the hash with the git header
QCryptographicHash crypto(QCryptographicHash::Sha1);
const QString header = QStringLiteral("blob %1").arg(f.size());
crypto.addData(header.toLatin1() + '\0');
while (!f.atEnd()) {
crypto.addData(f.read(256 * 1024));
}
digest = crypto.result();
}
}
/**
* set new digest
*/
m_buffer->setDigest(digest);
return !digest.isEmpty();
}
QString KTextEditor::DocumentPrivate::reasonedMOHString() const
{
// squeeze path
const QString str = KStringHandler::csqueeze(url().toDisplayString(QUrl::PreferLocalFile));
switch (m_modOnHdReason) {
case OnDiskModified:
return i18n("The file '%1' was modified by another program.", str);
break;
case OnDiskCreated:
return i18n("The file '%1' was created by another program.", str);
break;
case OnDiskDeleted:
return i18n("The file '%1' was deleted by another program.", str);
break;
default:
return QString();
}
Q_UNREACHABLE();
return QString();
}
void KTextEditor::DocumentPrivate::removeTrailingSpaces()
{
const int remove = config()->removeSpaces();
if (remove == 0) {
return;
}
// temporarily disable static word wrap (see bug #328900)
const bool wordWrapEnabled = config()->wordWrap();
if (wordWrapEnabled) {
setWordWrap(false);
}
editStart();
for (int line = 0; line < lines(); ++line) {
Kate::TextLine textline = plainKateTextLine(line);
// remove trailing spaces in entire document, remove = 2
// remove trailing spaces of touched lines, remove = 1
// remove trailing spaces of lines saved on disk, remove = 1
if (remove == 2 || textline->markedAsModified() || textline->markedAsSavedOnDisk()) {
const int p = textline->lastChar() + 1;
const int l = textline->length() - p;
if (l > 0) {
editRemoveText(line, p, l);
}
}
}
editEnd();
// enable word wrap again, if it was enabled (see bug #328900)
if (wordWrapEnabled) {
setWordWrap(true); // see begin of this function
}
}
void KTextEditor::DocumentPrivate::updateFileType(const QString &newType, bool user)
{
if (user || !m_fileTypeSetByUser) {
if (!newType.isEmpty()) {
// remember that we got set by user
m_fileTypeSetByUser = user;
m_fileType = newType;
m_config->configStart();
if (!m_hlSetByUser && !KTextEditor::EditorPrivate::self()->modeManager()->fileType(newType).hl.isEmpty()) {
int hl(KateHlManager::self()->nameFind(KTextEditor::EditorPrivate::self()->modeManager()->fileType(newType).hl));
if (hl >= 0) {
m_buffer->setHighlight(hl);
}
}
/**
* set the indentation mode, if any in the mode...
* and user did not set it before!
*/
if (!m_indenterSetByUser && !KTextEditor::EditorPrivate::self()->modeManager()->fileType(newType).indenter.isEmpty()) {
config()->setIndentationMode(KTextEditor::EditorPrivate::self()->modeManager()->fileType(newType).indenter);
}
// views!
KTextEditor::ViewPrivate *v;
foreach (v, m_views) {
v->config()->configStart();
v->renderer()->config()->configStart();
}
bool bom_settings = false;
if (m_bomSetByUser) {
bom_settings = m_config->bom();
}
readVariableLine(KTextEditor::EditorPrivate::self()->modeManager()->fileType(newType).varLine);
if (m_bomSetByUser) {
m_config->setBom(bom_settings);
}
m_config->configEnd();
foreach (v, m_views) {
v->config()->configEnd();
v->renderer()->config()->configEnd();
}
}
}
// fixme, make this better...
emit modeChanged(this);
}
void KTextEditor::DocumentPrivate::slotQueryClose_save(bool *handled, bool *abortClosing)
{
*handled = true;
*abortClosing = true;
if (this->url().isEmpty()) {
QWidget *parentWidget(dialogParent());
const QUrl res = QFileDialog::getSaveFileUrl(parentWidget, i18n("Save File"), QUrl(), {}, nullptr,
QFileDialog::DontConfirmOverwrite);
if (res.isEmpty() || !checkOverwrite(res, parentWidget)) {
*abortClosing = true;
return;
}
saveAs(res);
*abortClosing = false;
} else {
save();
*abortClosing = false;
}
}
bool KTextEditor::DocumentPrivate::checkOverwrite(QUrl u, QWidget *parent)
{
if (!u.isLocalFile()) {
return true;
}
QFileInfo info(u.path());
if (!info.exists()) {
return true;
}
return KMessageBox::Cancel != KMessageBox::warningContinueCancel(parent,
i18n("A file named \"%1\" already exists. "
"Are you sure you want to overwrite it?", info.fileName()),
i18n("Overwrite File?"), KStandardGuiItem::overwrite(),
KStandardGuiItem::cancel(), QString(), KMessageBox::Options(KMessageBox::Notify | KMessageBox::Dangerous));
}
//BEGIN KTextEditor::ConfigInterface
// BEGIN ConfigInterface stff
QStringList KTextEditor::DocumentPrivate::configKeys() const
{
static const QStringList keys = {
QLatin1String("backup-on-save-local"),
QLatin1String("backup-on-save-suffix"),
QLatin1String("backup-on-save-prefix"),
QLatin1String("replace-tabs"),
QLatin1String("indent-pasted-text"),
QLatin1String("tab-width"),
QLatin1String("indent-width"),
QLatin1String("on-the-fly-spellcheck"),
};
return keys;
}
QVariant KTextEditor::DocumentPrivate::configValue(const QString &key)
{
if (key == QLatin1String("backup-on-save-local")) {
return m_config->backupFlags() & KateDocumentConfig::LocalFiles;
} else if (key == QLatin1String("backup-on-save-remote")) {
return m_config->backupFlags() & KateDocumentConfig::RemoteFiles;
} else if (key == QLatin1String("backup-on-save-suffix")) {
return m_config->backupSuffix();
} else if (key == QLatin1String("backup-on-save-prefix")) {
return m_config->backupPrefix();
} else if (key == QLatin1String("replace-tabs")) {
return m_config->replaceTabsDyn();
} else if (key == QLatin1String("indent-pasted-text")) {
return m_config->indentPastedText();
} else if (key == QLatin1String("tab-width")) {
return m_config->tabWidth();
} else if (key == QLatin1String("indent-width")) {
return m_config->indentationWidth();
} else if (key == QLatin1String("on-the-fly-spellcheck")) {
return isOnTheFlySpellCheckingEnabled();
}
// return invalid variant
return QVariant();
}
void KTextEditor::DocumentPrivate::setConfigValue(const QString &key, const QVariant &value)
{
if (value.type() == QVariant::String) {
if (key == QLatin1String("backup-on-save-suffix")) {
m_config->setBackupSuffix(value.toString());
} else if (key == QLatin1String("backup-on-save-prefix")) {
m_config->setBackupPrefix(value.toString());
}
} else if (value.type() == QVariant::Bool) {
const bool bValue = value.toBool();
if (key == QLatin1String("backup-on-save-local")) {
uint f = m_config->backupFlags();
if (bValue) {
f |= KateDocumentConfig::LocalFiles;
} else {
f ^= KateDocumentConfig::LocalFiles;
}
m_config->setBackupFlags(f);
} else if (key == QLatin1String("backup-on-save-remote")) {
uint f = m_config->backupFlags();
if (bValue) {
f |= KateDocumentConfig::RemoteFiles;
} else {
f ^= KateDocumentConfig::RemoteFiles;
}
m_config->setBackupFlags(f);
} else if (key == QLatin1String("replace-tabs")) {
m_config->setReplaceTabsDyn(bValue);
} else if (key == QLatin1String("indent-pasted-text")) {
m_config->setIndentPastedText(bValue);
} else if (key == QLatin1String("on-the-fly-spellcheck")) {
onTheFlySpellCheckingEnabled(bValue);
}
} else if (value.canConvert(QVariant::Int)) {
if (key == QLatin1String("tab-width")) {
config()->setTabWidth(value.toInt());
} else if (key == QLatin1String("indent-width")) {
config()->setIndentationWidth(value.toInt());
}
}
}
//END KTextEditor::ConfigInterface
KTextEditor::Cursor KTextEditor::DocumentPrivate::documentEnd() const
{
return KTextEditor::Cursor(lastLine(), lineLength(lastLine()));
}
bool KTextEditor::DocumentPrivate::replaceText(const KTextEditor::Range &range, const QString &s, bool block)
{
// TODO more efficient?
editStart();
bool changed = removeText(range, block);
changed |= insertText(range.start(), s, block);
editEnd();
return changed;
}
KateHighlighting *KTextEditor::DocumentPrivate::highlight() const
{
return m_buffer->highlight();
}
Kate::TextLine KTextEditor::DocumentPrivate::kateTextLine(int i)
{
m_buffer->ensureHighlighted(i);
return m_buffer->plainLine(i);
}
Kate::TextLine KTextEditor::DocumentPrivate::plainKateTextLine(int i)
{
return m_buffer->plainLine(i);
}
bool KTextEditor::DocumentPrivate::isEditRunning() const
{
return editIsRunning;
}
void KTextEditor::DocumentPrivate::setUndoMergeAllEdits(bool merge)
{
if (merge && m_undoMergeAllEdits) {
// Don't add another undo safe point: it will override our current one,
// meaning we'll need two undo's to get back there - which defeats the object!
return;
}
m_undoManager->undoSafePoint();
m_undoManager->setAllowComplexMerge(merge);
m_undoMergeAllEdits = merge;
}
//BEGIN KTextEditor::MovingInterface
KTextEditor::MovingCursor *KTextEditor::DocumentPrivate::newMovingCursor(const KTextEditor::Cursor &position, KTextEditor::MovingCursor::InsertBehavior insertBehavior)
{
return new Kate::TextCursor(buffer(), position, insertBehavior);
}
KTextEditor::MovingRange *KTextEditor::DocumentPrivate::newMovingRange(const KTextEditor::Range &range, KTextEditor::MovingRange::InsertBehaviors insertBehaviors, KTextEditor::MovingRange::EmptyBehavior emptyBehavior)
{
return new Kate::TextRange(buffer(), range, insertBehaviors, emptyBehavior);
}
qint64 KTextEditor::DocumentPrivate::revision() const
{
return m_buffer->history().revision();
}
qint64 KTextEditor::DocumentPrivate::lastSavedRevision() const
{
return m_buffer->history().lastSavedRevision();
}
void KTextEditor::DocumentPrivate::lockRevision(qint64 revision)
{
m_buffer->history().lockRevision(revision);
}
void KTextEditor::DocumentPrivate::unlockRevision(qint64 revision)
{
m_buffer->history().unlockRevision(revision);
}
void KTextEditor::DocumentPrivate::transformCursor(int &line, int &column, KTextEditor::MovingCursor::InsertBehavior insertBehavior, qint64 fromRevision, qint64 toRevision)
{
m_buffer->history().transformCursor(line, column, insertBehavior, fromRevision, toRevision);
}
void KTextEditor::DocumentPrivate::transformCursor(KTextEditor::Cursor &cursor, KTextEditor::MovingCursor::InsertBehavior insertBehavior, qint64 fromRevision, qint64 toRevision)
{
int line = cursor.line(), column = cursor.column();
m_buffer->history().transformCursor(line, column, insertBehavior, fromRevision, toRevision);
cursor.setLine(line);
cursor.setColumn(column);
}
void KTextEditor::DocumentPrivate::transformRange(KTextEditor::Range &range, KTextEditor::MovingRange::InsertBehaviors insertBehaviors, KTextEditor::MovingRange::EmptyBehavior emptyBehavior, qint64 fromRevision, qint64 toRevision)
{
m_buffer->history().transformRange(range, insertBehaviors, emptyBehavior, fromRevision, toRevision);
}
//END
//BEGIN KTextEditor::AnnotationInterface
void KTextEditor::DocumentPrivate::setAnnotationModel(KTextEditor::AnnotationModel *model)
{
KTextEditor::AnnotationModel *oldmodel = m_annotationModel;
m_annotationModel = model;
emit annotationModelChanged(oldmodel, m_annotationModel);
}
KTextEditor::AnnotationModel *KTextEditor::DocumentPrivate::annotationModel() const
{
return m_annotationModel;
}
//END KTextEditor::AnnotationInterface
//TAKEN FROM kparts.h
bool KTextEditor::DocumentPrivate::queryClose()
{
if (!isReadWrite() || !isModified()) {
return true;
}
QString docName = documentName();
int res = KMessageBox::warningYesNoCancel(dialogParent(),
i18n("The document \"%1\" has been modified.\n"
"Do you want to save your changes or discard them?", docName),
i18n("Close Document"), KStandardGuiItem::save(), KStandardGuiItem::discard());
bool abortClose = false;
bool handled = false;
switch (res) {
case KMessageBox::Yes :
sigQueryClose(&handled, &abortClose);
if (!handled) {
if (url().isEmpty()) {
QUrl url = QFileDialog::getSaveFileUrl(dialogParent());
if (url.isEmpty()) {
return false;
}
saveAs(url);
} else {
save();
}
} else if (abortClose) {
return false;
}
return waitSaveComplete();
case KMessageBox::No :
return true;
default : // case KMessageBox::Cancel :
return false;
}
}
void KTextEditor::DocumentPrivate::slotStarted(KIO::Job *job)
{
/**
* if we are idle before, we are now loading!
*/
if (m_documentState == DocumentIdle) {
m_documentState = DocumentLoading;
}
/**
* if loading:
* - remember pre loading read-write mode
* if remote load:
* - set to read-only
* - trigger possible message
*/
if (m_documentState == DocumentLoading) {
/**
* remember state
*/
m_readWriteStateBeforeLoading = isReadWrite();
/**
* perhaps show loading message, but wait one second
*/
if (job) {
/**
* only read only if really remote file!
*/
setReadWrite(false);
/**
* perhaps some message about loading in one second!
* remember job pointer, we want to be able to kill it!
*/
m_loadingJob = job;
QTimer::singleShot(1000, this, SLOT(slotTriggerLoadingMessage()));
}
}
}
void KTextEditor::DocumentPrivate::slotCompleted()
{
/**
* if were loading, reset back to old read-write mode before loading
* and kill the possible loading message
*/
if (m_documentState == DocumentLoading) {
setReadWrite(m_readWriteStateBeforeLoading);
delete m_loadingMessage;
}
/**
* Emit signal that we saved the document, if needed
*/
if (m_documentState == DocumentSaving || m_documentState == DocumentSavingAs) {
emit documentSavedOrUploaded(this, m_documentState == DocumentSavingAs);
}
/**
* back to idle mode
*/
m_documentState = DocumentIdle;
m_reloading = false;
}
void KTextEditor::DocumentPrivate::slotCanceled()
{
/**
* if were loading, reset back to old read-write mode before loading
* and kill the possible loading message
*/
if (m_documentState == DocumentLoading) {
setReadWrite(m_readWriteStateBeforeLoading);
delete m_loadingMessage;
showAndSetOpeningErrorAccess();
updateDocName();
}
/**
* back to idle mode
*/
m_documentState = DocumentIdle;
m_reloading = false;
}
void KTextEditor::DocumentPrivate::slotTriggerLoadingMessage()
{
/**
* no longer loading?
* no message needed!
*/
if (m_documentState != DocumentLoading) {
return;
}
/**
* create message about file loading in progress
*/
delete m_loadingMessage;
m_loadingMessage = new KTextEditor::Message(i18n("The file %2 is still loading.", url().toDisplayString(QUrl::PreferLocalFile), url().fileName()));
m_loadingMessage->setPosition(KTextEditor::Message::TopInView);
/**
* if around job: add cancel action
*/
if (m_loadingJob) {
QAction *cancel = new QAction(i18n("&Abort Loading"), nullptr);
connect(cancel, SIGNAL(triggered()), this, SLOT(slotAbortLoading()));
m_loadingMessage->addAction(cancel);
}
/**
* really post message
*/
postMessage(m_loadingMessage);
}
void KTextEditor::DocumentPrivate::slotAbortLoading()
{
/**
* no job, no work
*/
if (!m_loadingJob) {
return;
}
/**
* abort loading if any job
* signal results!
*/
m_loadingJob->kill(KJob::EmitResult);
m_loadingJob = nullptr;
}
void KTextEditor::DocumentPrivate::slotUrlChanged(const QUrl &url)
{
if (m_reloading) {
// the URL is temporarily unset and then reset to the previous URL during reload
// we do not want to notify the outside about this
return;
}
Q_UNUSED(url);
updateDocName();
emit documentUrlChanged(this);
}
bool KTextEditor::DocumentPrivate::save()
{
/**
* no double save/load
* we need to allow DocumentPreSavingAs here as state, as save is called in saveAs!
*/
if ((m_documentState != DocumentIdle) && (m_documentState != DocumentPreSavingAs)) {
return false;
}
/**
* if we are idle, we are now saving
*/
if (m_documentState == DocumentIdle) {
m_documentState = DocumentSaving;
} else {
m_documentState = DocumentSavingAs;
}
/**
* call back implementation for real work
*/
return KTextEditor::Document::save();
}
bool KTextEditor::DocumentPrivate::saveAs(const QUrl &url)
{
/**
* abort on bad URL
* that is done in saveAs below, too
* but we must check it here already to avoid messing up
* as no signals will be send, then
*/
if (!url.isValid()) {
return false;
}
/**
* no double save/load
*/
if (m_documentState != DocumentIdle) {
return false;
}
/**
* we enter the pre save as phase
*/
m_documentState = DocumentPreSavingAs;
/**
* call base implementation for real work
*/
return KTextEditor::Document::saveAs(normalizeUrl(url));
}
QString KTextEditor::DocumentPrivate::defaultDictionary() const
{
return m_defaultDictionary;
}
QList > KTextEditor::DocumentPrivate::dictionaryRanges() const
{
return m_dictionaryRanges;
}
void KTextEditor::DocumentPrivate::clearDictionaryRanges()
{
for (QList >::iterator i = m_dictionaryRanges.begin();
i != m_dictionaryRanges.end(); ++i) {
delete(*i).first;
}
m_dictionaryRanges.clear();
if (m_onTheFlyChecker) {
m_onTheFlyChecker->refreshSpellCheck();
}
emit dictionaryRangesPresent(false);
}
void KTextEditor::DocumentPrivate::setDictionary(const QString &newDictionary, const KTextEditor::Range &range)
{
KTextEditor::Range newDictionaryRange = range;
if (!newDictionaryRange.isValid() || newDictionaryRange.isEmpty()) {
return;
}
QList > newRanges;
// all ranges is 'm_dictionaryRanges' are assumed to be mutually disjoint
for (QList >::iterator i = m_dictionaryRanges.begin();
i != m_dictionaryRanges.end();) {
qCDebug(LOG_KTE) << "new iteration" << newDictionaryRange;
if (newDictionaryRange.isEmpty()) {
break;
}
QPair pair = *i;
QString dictionarySet = pair.second;
KTextEditor::MovingRange *dictionaryRange = pair.first;
qCDebug(LOG_KTE) << *dictionaryRange << dictionarySet;
if (dictionaryRange->contains(newDictionaryRange) && newDictionary == dictionarySet) {
qCDebug(LOG_KTE) << "dictionaryRange contains newDictionaryRange";
return;
}
if (newDictionaryRange.contains(*dictionaryRange)) {
delete dictionaryRange;
i = m_dictionaryRanges.erase(i);
qCDebug(LOG_KTE) << "newDictionaryRange contains dictionaryRange";
continue;
}
KTextEditor::Range intersection = dictionaryRange->toRange().intersect(newDictionaryRange);
if (!intersection.isEmpty() && intersection.isValid()) {
if (dictionarySet == newDictionary) { // we don't have to do anything for 'intersection'
// except cut off the intersection
QList remainingRanges = KateSpellCheckManager::rangeDifference(newDictionaryRange, intersection);
Q_ASSERT(remainingRanges.size() == 1);
newDictionaryRange = remainingRanges.first();
++i;
qCDebug(LOG_KTE) << "dictionarySet == newDictionary";
continue;
}
QList remainingRanges = KateSpellCheckManager::rangeDifference(*dictionaryRange, intersection);
for (QList::iterator j = remainingRanges.begin(); j != remainingRanges.end(); ++j) {
KTextEditor::MovingRange *remainingRange = newMovingRange(*j,
KTextEditor::MovingRange::ExpandLeft | KTextEditor::MovingRange::ExpandRight);
remainingRange->setFeedback(this);
newRanges.push_back(QPair(remainingRange, dictionarySet));
}
i = m_dictionaryRanges.erase(i);
delete dictionaryRange;
} else {
++i;
}
}
m_dictionaryRanges += newRanges;
if (!newDictionaryRange.isEmpty() && !newDictionary.isEmpty()) { // we don't add anything for the default dictionary
KTextEditor::MovingRange *newDictionaryMovingRange = newMovingRange(newDictionaryRange,
KTextEditor::MovingRange::ExpandLeft | KTextEditor::MovingRange::ExpandRight);
newDictionaryMovingRange->setFeedback(this);
m_dictionaryRanges.push_back(QPair(newDictionaryMovingRange, newDictionary));
}
if (m_onTheFlyChecker && !newDictionaryRange.isEmpty()) {
m_onTheFlyChecker->refreshSpellCheck(newDictionaryRange);
}
emit dictionaryRangesPresent(!m_dictionaryRanges.isEmpty());
}
void KTextEditor::DocumentPrivate::revertToDefaultDictionary(const KTextEditor::Range &range)
{
setDictionary(QString(), range);
}
void KTextEditor::DocumentPrivate::setDefaultDictionary(const QString &dict)
{
if (m_defaultDictionary == dict) {
return;
}
m_defaultDictionary = dict;
if (m_onTheFlyChecker) {
m_onTheFlyChecker->updateConfig();
refreshOnTheFlyCheck();
}
emit defaultDictionaryChanged(this);
}
void KTextEditor::DocumentPrivate::onTheFlySpellCheckingEnabled(bool enable)
{
if (isOnTheFlySpellCheckingEnabled() == enable) {
return;
}
if (enable) {
Q_ASSERT(m_onTheFlyChecker == nullptr);
m_onTheFlyChecker = new KateOnTheFlyChecker(this);
} else {
delete m_onTheFlyChecker;
m_onTheFlyChecker = nullptr;
}
foreach (KTextEditor::ViewPrivate *view, m_views) {
view->reflectOnTheFlySpellCheckStatus(enable);
}
}
bool KTextEditor::DocumentPrivate::isOnTheFlySpellCheckingEnabled() const
{
return m_onTheFlyChecker != nullptr;
}
QString KTextEditor::DocumentPrivate::dictionaryForMisspelledRange(const KTextEditor::Range &range) const
{
if (!m_onTheFlyChecker) {
return QString();
} else {
return m_onTheFlyChecker->dictionaryForMisspelledRange(range);
}
}
void KTextEditor::DocumentPrivate::clearMisspellingForWord(const QString &word)
{
if (m_onTheFlyChecker) {
m_onTheFlyChecker->clearMisspellingForWord(word);
}
}
void KTextEditor::DocumentPrivate::refreshOnTheFlyCheck(const KTextEditor::Range &range)
{
if (m_onTheFlyChecker) {
m_onTheFlyChecker->refreshSpellCheck(range);
}
}
void KTextEditor::DocumentPrivate::rangeInvalid(KTextEditor::MovingRange *movingRange)
{
deleteDictionaryRange(movingRange);
}
void KTextEditor::DocumentPrivate::rangeEmpty(KTextEditor::MovingRange *movingRange)
{
deleteDictionaryRange(movingRange);
}
void KTextEditor::DocumentPrivate::deleteDictionaryRange(KTextEditor::MovingRange *movingRange)
{
qCDebug(LOG_KTE) << "deleting" << movingRange;
auto finder = [=] (const QPair& item) -> bool {
return item.first == movingRange;
};
auto it = std::find_if(m_dictionaryRanges.begin(), m_dictionaryRanges.end(), finder);
if (it != m_dictionaryRanges.end()) {
m_dictionaryRanges.erase(it);
delete movingRange;
}
Q_ASSERT(std::find_if(m_dictionaryRanges.begin(), m_dictionaryRanges.end(), finder) == m_dictionaryRanges.end());
}
bool KTextEditor::DocumentPrivate::containsCharacterEncoding(const KTextEditor::Range &range)
{
KateHighlighting *highlighting = highlight();
Kate::TextLine textLine;
const int rangeStartLine = range.start().line();
const int rangeStartColumn = range.start().column();
const int rangeEndLine = range.end().line();
const int rangeEndColumn = range.end().column();
for (int line = range.start().line(); line <= rangeEndLine; ++line) {
textLine = kateTextLine(line);
int startColumn = (line == rangeStartLine) ? rangeStartColumn : 0;
int endColumn = (line == rangeEndLine) ? rangeEndColumn : textLine->length();
for (int col = startColumn; col < endColumn; ++col) {
int attr = textLine->attribute(col);
const KatePrefixStore &prefixStore = highlighting->getCharacterEncodingsPrefixStore(attr);
if (!prefixStore.findPrefix(textLine, col).isEmpty()) {
return true;
}
}
}
return false;
}
int KTextEditor::DocumentPrivate::computePositionWrtOffsets(const OffsetList &offsetList, int pos)
{
int previousOffset = 0;
for (OffsetList::const_iterator i = offsetList.begin(); i != offsetList.end(); ++i) {
if ((*i).first > pos) {
break;
}
previousOffset = (*i).second;
}
return pos + previousOffset;
}
QString KTextEditor::DocumentPrivate::decodeCharacters(const KTextEditor::Range &range, KTextEditor::DocumentPrivate::OffsetList &decToEncOffsetList,
KTextEditor::DocumentPrivate::OffsetList &encToDecOffsetList)
{
QString toReturn;
KTextEditor::Cursor previous = range.start();
int decToEncCurrentOffset = 0, encToDecCurrentOffset = 0;
int i = 0;
int newI = 0;
KateHighlighting *highlighting = highlight();
Kate::TextLine textLine;
const int rangeStartLine = range.start().line();
const int rangeStartColumn = range.start().column();
const int rangeEndLine = range.end().line();
const int rangeEndColumn = range.end().column();
for (int line = range.start().line(); line <= rangeEndLine; ++line) {
textLine = kateTextLine(line);
int startColumn = (line == rangeStartLine) ? rangeStartColumn : 0;
int endColumn = (line == rangeEndLine) ? rangeEndColumn : textLine->length();
for (int col = startColumn; col < endColumn;) {
int attr = textLine->attribute(col);
const KatePrefixStore &prefixStore = highlighting->getCharacterEncodingsPrefixStore(attr);
const QHash &characterEncodingsHash = highlighting->getCharacterEncodings(attr);
QString matchingPrefix = prefixStore.findPrefix(textLine, col);
if (!matchingPrefix.isEmpty()) {
toReturn += text(KTextEditor::Range(previous, KTextEditor::Cursor(line, col)));
const QChar &c = characterEncodingsHash.value(matchingPrefix);
const bool isNullChar = c.isNull();
if (!c.isNull()) {
toReturn += c;
}
i += matchingPrefix.length();
col += matchingPrefix.length();
previous = KTextEditor::Cursor(line, col);
decToEncCurrentOffset = decToEncCurrentOffset - (isNullChar ? 0 : 1) + matchingPrefix.length();
encToDecCurrentOffset = encToDecCurrentOffset - matchingPrefix.length() + (isNullChar ? 0 : 1);
newI += (isNullChar ? 0 : 1);
decToEncOffsetList.push_back(QPair(newI, decToEncCurrentOffset));
encToDecOffsetList.push_back(QPair(i, encToDecCurrentOffset));
continue;
}
++col;
++i;
++newI;
}
++i;
++newI;
}
if (previous < range.end()) {
toReturn += text(KTextEditor::Range(previous, range.end()));
}
return toReturn;
}
void KTextEditor::DocumentPrivate::replaceCharactersByEncoding(const KTextEditor::Range &range)
{
KateHighlighting *highlighting = highlight();
Kate::TextLine textLine;
const int rangeStartLine = range.start().line();
const int rangeStartColumn = range.start().column();
const int rangeEndLine = range.end().line();
const int rangeEndColumn = range.end().column();
for (int line = range.start().line(); line <= rangeEndLine; ++line) {
textLine = kateTextLine(line);
int startColumn = (line == rangeStartLine) ? rangeStartColumn : 0;
int endColumn = (line == rangeEndLine) ? rangeEndColumn : textLine->length();
for (int col = startColumn; col < endColumn;) {
int attr = textLine->attribute(col);
const QHash &reverseCharacterEncodingsHash = highlighting->getReverseCharacterEncodings(attr);
QHash::const_iterator it = reverseCharacterEncodingsHash.find(textLine->at(col));
if (it != reverseCharacterEncodingsHash.end()) {
replaceText(KTextEditor::Range(line, col, line, col + 1), *it);
col += (*it).length();
continue;
}
++col;
}
}
}
//
// Highlighting information
//
KTextEditor::Attribute::Ptr KTextEditor::DocumentPrivate::attributeAt(const KTextEditor::Cursor &position)
{
KTextEditor::Attribute::Ptr attrib(new KTextEditor::Attribute());
KTextEditor::ViewPrivate *view = m_views.empty() ? nullptr : m_views.begin().value();
if (!view) {
qCWarning(LOG_KTE) << "ATTENTION: cannot access lineAttributes() without any View (will be fixed eventually)";
return attrib;
}
Kate::TextLine kateLine = kateTextLine(position.line());
if (!kateLine) {
return attrib;
}
*attrib = *view->renderer()->attribute(kateLine->attribute(position.column()));
return attrib;
}
QStringList KTextEditor::DocumentPrivate::embeddedHighlightingModes() const
{
return highlight()->getEmbeddedHighlightingModes();
}
QString KTextEditor::DocumentPrivate::highlightingModeAt(const KTextEditor::Cursor &position)
{
return highlight()->higlightingModeForLocation(this, position);
}
Kate::SwapFile *KTextEditor::DocumentPrivate::swapFile()
{
return m_swapfile;
}
/**
* \return \c -1 if \c line or \c column invalid, otherwise one of
* standard style attribute number
*/
int KTextEditor::DocumentPrivate::defStyleNum(int line, int column)
{
// Validate parameters to prevent out of range access
if (line < 0 || line >= lines() || column < 0) {
return -1;
}
// get highlighted line
Kate::TextLine tl = kateTextLine(line);
// make sure the textline is a valid pointer
if (!tl) {
return -1;
}
/**
* either get char attribute or attribute of context still active at end of line
*/
int attribute = 0;
if (column < tl->length()) {
attribute = tl->attribute(column);
} else if (column == tl->length()) {
if (!tl->attributesList().isEmpty()) {
attribute = tl->attributesList().back().attributeValue;
} else {
return -1;
}
} else {
return -1;
}
return highlight()->defaultStyleForAttribute(attribute);
}
bool KTextEditor::DocumentPrivate::isComment(int line, int column)
{
const int defaultStyle = defStyleNum(line, column);
return defaultStyle == KTextEditor::dsComment;
}
int KTextEditor::DocumentPrivate::findTouchedLine(int startLine, bool down)
{
const int offset = down ? 1 : -1;
const int lineCount = lines();
while (startLine >= 0 && startLine < lineCount) {
Kate::TextLine tl = m_buffer->plainLine(startLine);
if (tl && (tl->markedAsModified() || tl->markedAsSavedOnDisk())) {
return startLine;
}
startLine += offset;
}
return -1;
}
void KTextEditor::DocumentPrivate::setActiveTemplateHandler(KateTemplateHandler* handler)
{
// delete any active template handler
delete m_activeTemplateHandler.data();
m_activeTemplateHandler = handler;
}
//BEGIN KTextEditor::MessageInterface
bool KTextEditor::DocumentPrivate::postMessage(KTextEditor::Message *message)
{
// no message -> cancel
if (!message) {
return false;
}
// make sure the desired view belongs to this document
if (message->view() && message->view()->document() != this) {
qCWarning(LOG_KTE) << "trying to post a message to a view of another document:" << message->text();
return false;
}
message->setParent(this);
message->setDocument(this);
// if there are no actions, add a close action by default if widget does not auto-hide
if (message->actions().count() == 0 && message->autoHide() < 0) {
QAction *closeAction = new QAction(QIcon::fromTheme(QStringLiteral("window-close")), i18n("&Close"), nullptr);
closeAction->setToolTip(i18n("Close message"));
message->addAction(closeAction);
}
// make sure the message is registered even if no actions and no views exist
m_messageHash[message] = QList >();
// reparent actions, as we want full control over when they are deleted
foreach (QAction *action, message->actions()) {
action->setParent(nullptr);
m_messageHash[message].append(QSharedPointer(action));
}
// post message to requested view, or to all views
if (KTextEditor::ViewPrivate *view = qobject_cast(message->view())) {
view->postMessage(message, m_messageHash[message]);
} else {
foreach (KTextEditor::ViewPrivate *view, m_views) {
view->postMessage(message, m_messageHash[message]);
}
}
// also catch if the user manually calls delete message
connect(message, SIGNAL(closed(KTextEditor::Message*)), SLOT(messageDestroyed(KTextEditor::Message*)));
return true;
}
void KTextEditor::DocumentPrivate::messageDestroyed(KTextEditor::Message *message)
{
// KTE:Message is already in destructor
Q_ASSERT(m_messageHash.contains(message));
m_messageHash.remove(message);
}
//END KTextEditor::MessageInterface
void KTextEditor::DocumentPrivate::closeDocumentInApplication()
{
KTextEditor::EditorPrivate::self()->application()->closeDocument(this);
}
diff --git a/src/mode/katemodeconfigpage.cpp b/src/mode/katemodeconfigpage.cpp
index cc2c4e1a..c638a9ea 100644
--- a/src/mode/katemodeconfigpage.cpp
+++ b/src/mode/katemodeconfigpage.cpp
@@ -1,307 +1,306 @@
/* This file is part of the KDE libraries and the Kate part.
*
* Copyright (C) 2001-2010 Christoph Cullmann
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Library General Public
* License as published by the Free Software Foundation; either
* version 2 of the License, or (at your option) any later version.
*
* This library 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
* Library General Public License for more details.
*
* You should have received a copy of the GNU Library General Public License
* along with this library; see the file COPYING.LIB. If not, write to
* the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
* Boston, MA 02110-1301, USA.
*/
//BEGIN Includes
#include "katemodeconfigpage.h"
#include "katedocument.h"
#include "kateconfig.h"
#include "kateview.h"
#include "kateglobal.h"
#include "kateautoindent.h"
#include "katesyntaxmanager.h"
#include "ui_filetypeconfigwidget.h"
#include
#include "katepartdebug.h"
#include
#include
#include
#include
#include
#include
#include
#include
//END Includes
ModeConfigPage::ModeConfigPage(QWidget *parent)
: KateConfigPage(parent)
{
m_lastType = -1;
// This will let us have more separation between this page and
// the QTabWidget edge (ereslibre)
QVBoxLayout *layout = new QVBoxLayout;
QWidget *newWidget = new QWidget(this);
ui = new Ui::FileTypeConfigWidget();
ui->setupUi(newWidget);
ui->cmbHl->addItem(i18n(""), QVariant(QString()));
- for (int i = 0; i < KateHlManager::self()->highlights(); i++) {
- if (KateHlManager::self()->hlSection(i).length() > 0)
- ui->cmbHl->addItem(KateHlManager::self()->hlSection(i) + QLatin1String("/")
- + KateHlManager::self()->hlNameTranslated(i), QVariant(KateHlManager::self()->hlName(i)));
+ for (const auto &hl : KateHlManager::self()->modeList()) {
+ if (hl.section().length() > 0)
+ ui->cmbHl->addItem(hl.section() + QLatin1String("/") + hl.translatedName(), QVariant(hl.name()));
else {
- ui->cmbHl->addItem(KateHlManager::self()->hlNameTranslated(i), QVariant(KateHlManager::self()->hlName(i)));
+ ui->cmbHl->addItem(hl.translatedName(), QVariant(hl.name()));
}
}
QStringList indentationModes;
indentationModes << i18n("Use Default");
indentationModes << KateAutoIndent::listModes();
ui->cmbIndenter->addItems(indentationModes);
connect(ui->cmbFiletypes, SIGNAL(activated(int)), this, SLOT(typeChanged(int)));
connect(ui->btnNew, SIGNAL(clicked()), this, SLOT(newType()));
connect(ui->btnDelete, SIGNAL(clicked()), this, SLOT(deleteType()));
ui->btnMimeTypes->setIcon(QIcon::fromTheme(QStringLiteral("tools-wizard")));
connect(ui->btnMimeTypes, SIGNAL(clicked()), this, SLOT(showMTDlg()));
connect(ui->btnDownload, SIGNAL(clicked()), this, SLOT(hlDownload()));
reload();
connect(ui->edtName, SIGNAL(textChanged(QString)), this, SLOT(slotChanged()));
connect(ui->edtSection, SIGNAL(textChanged(QString)), this, SLOT(slotChanged()));
connect(ui->edtVariables, SIGNAL(textChanged(QString)), this, SLOT(slotChanged()));
connect(ui->edtFileExtensions, SIGNAL(textChanged(QString)), this, SLOT(slotChanged()));
connect(ui->edtMimeTypes, SIGNAL(textChanged(QString)), this, SLOT(slotChanged()));
connect(ui->sbPriority, SIGNAL(valueChanged(int)), this, SLOT(slotChanged()));
connect(ui->cmbHl, SIGNAL(activated(int)), this, SLOT(slotChanged()));
connect(ui->cmbIndenter, SIGNAL(activated(int)), this, SLOT(slotChanged()));
layout->addWidget(newWidget);
setLayout(layout);
}
ModeConfigPage::~ModeConfigPage()
{
qDeleteAll(m_types);
delete ui;
}
void ModeConfigPage::apply()
{
if (!hasChanged()) {
return;
}
save();
KTextEditor::EditorPrivate::self()->modeManager()->save(m_types);
}
void ModeConfigPage::reload()
{
qDeleteAll(m_types);
m_types.clear();
// deep copy...
foreach (KateFileType *type, KTextEditor::EditorPrivate::self()->modeManager()->list()) {
KateFileType *t = new KateFileType();
*t = *type;
m_types.append(t);
}
update();
}
void ModeConfigPage::reset()
{
reload();
}
void ModeConfigPage::defaults()
{
reload();
}
void ModeConfigPage::update()
{
m_lastType = -1;
ui->cmbFiletypes->clear();
foreach (KateFileType *type, m_types) {
if (!type->sectionTranslated().isEmpty()) {
ui->cmbFiletypes->addItem(type->sectionTranslated() + QLatin1String("/") + type->nameTranslated());
} else {
ui->cmbFiletypes->addItem(type->nameTranslated());
}
}
// get current filetype from active view via the host application
int currentIndex = 0;
KTextEditor::ViewPrivate *kv = qobject_cast(KTextEditor::EditorPrivate::self()->application()->activeMainWindow()->activeView());
if (kv) {
const QString filetypeName = kv->doc()->fileType();
for (int i = 0; i < m_types.size(); ++i) {
if (filetypeName == m_types[i]->name) {
currentIndex = i;
break;
}
}
}
ui->cmbFiletypes->setCurrentIndex(currentIndex);
typeChanged(currentIndex);
ui->cmbFiletypes->setEnabled(ui->cmbFiletypes->count() > 0);
}
void ModeConfigPage::deleteType()
{
int type = ui->cmbFiletypes->currentIndex();
if (type > -1 && type < m_types.count()) {
delete m_types[type];
m_types.removeAt(type);
update();
}
}
void ModeConfigPage::newType()
{
QString newN = i18n("New Filetype");
for (int i = 0; i < m_types.count(); ++i) {
KateFileType *type = m_types.at(i);
if (type->name == newN) {
ui->cmbFiletypes->setCurrentIndex(i);
typeChanged(i);
return;
}
}
KateFileType *newT = new KateFileType();
newT->priority = 0;
newT->name = newN;
newT->hlGenerated = false;
m_types.prepend(newT);
update();
}
void ModeConfigPage::save()
{
if (m_lastType != -1) {
if (!m_types[m_lastType]->hlGenerated) {
m_types[m_lastType]->name = ui->edtName->text();
m_types[m_lastType]->section = ui->edtSection->text();
}
m_types[m_lastType]->varLine = ui->edtVariables->text();
m_types[m_lastType]->wildcards = ui->edtFileExtensions->text().split(QLatin1Char(';'), QString::SkipEmptyParts);
m_types[m_lastType]->mimetypes = ui->edtMimeTypes->text().split(QLatin1Char(';'), QString::SkipEmptyParts);
m_types[m_lastType]->priority = ui->sbPriority->value();
m_types[m_lastType]->hl = ui->cmbHl->itemData(ui->cmbHl->currentIndex()).toString();
if (ui->cmbIndenter->currentIndex() > 0) {
m_types[m_lastType]->indenter = KateAutoIndent::modeName(ui->cmbIndenter->currentIndex() - 1);
} else {
m_types[m_lastType]->indenter = QString();
}
}
}
void ModeConfigPage::typeChanged(int type)
{
save();
ui->cmbHl->setEnabled(true);
ui->btnDelete->setEnabled(true);
ui->edtName->setEnabled(true);
ui->edtSection->setEnabled(true);
if (type > -1 && type < m_types.count()) {
KateFileType *t = m_types.at(type);
ui->gbProperties->setTitle(i18n("Properties of %1", ui->cmbFiletypes->currentText()));
ui->gbProperties->setEnabled(true);
ui->btnDelete->setEnabled(true);
ui->edtName->setText(t->nameTranslated());
ui->edtSection->setText(t->sectionTranslated());
ui->edtVariables->setText(t->varLine);
ui->edtFileExtensions->setText(t->wildcards.join(QLatin1Char(';')));
ui->edtMimeTypes->setText(t->mimetypes.join(QLatin1Char(';')));
ui->sbPriority->setValue(t->priority);
ui->cmbHl->setEnabled(!t->hlGenerated);
ui->btnDelete->setEnabled(!t->hlGenerated);
ui->edtName->setEnabled(!t->hlGenerated);
ui->edtSection->setEnabled(!t->hlGenerated);
// activate current hl...
for (int i = 0; i < ui->cmbHl->count(); ++i)
if (ui->cmbHl->itemData(i).toString() == t->hl) {
ui->cmbHl->setCurrentIndex(i);
}
// activate the right indenter
int indenterIndex = 0;
if (!t->indenter.isEmpty()) {
indenterIndex = KateAutoIndent::modeNumber(t->indenter) + 1;
}
ui->cmbIndenter->setCurrentIndex(indenterIndex);
} else {
ui->gbProperties->setTitle(i18n("Properties"));
ui->gbProperties->setEnabled(false);
ui->btnDelete->setEnabled(false);
ui->edtName->clear();
ui->edtSection->clear();
ui->edtVariables->clear();
ui->edtFileExtensions->clear();
ui->edtMimeTypes->clear();
ui->sbPriority->setValue(0);
ui->cmbHl->setCurrentIndex(0);
ui->cmbIndenter->setCurrentIndex(0);
}
m_lastType = type;
}
void ModeConfigPage::showMTDlg()
{
QString text = i18n("Select the MimeTypes you want for this file type.\nPlease note that this will automatically edit the associated file extensions as well.");
QStringList list = ui->edtMimeTypes->text().split(QRegularExpression(QStringLiteral("\\s*;\\s*")), QString::SkipEmptyParts);
KMimeTypeChooserDialog d(i18n("Select Mime Types"), text, list, QStringLiteral("text"), this);
if (d.exec() == QDialog::Accepted) {
// do some checking, warn user if mime types or patterns are removed.
// if the lists are empty, and the fields not, warn.
ui->edtFileExtensions->setText(d.chooser()->patterns().join(QLatin1Char(';')));
ui->edtMimeTypes->setText(d.chooser()->mimeTypes().join(QLatin1Char(';')));
}
}
void ModeConfigPage::hlDownload()
{
KateHlDownloadDialog diag(this, "hlDownload", true);
diag.exec();
}
QString ModeConfigPage::name() const
{
return i18n("Modes && Filetypes");
}
diff --git a/src/schema/kateschemaconfig.cpp b/src/schema/kateschemaconfig.cpp
index 0b245441..36ea3a40 100644
--- a/src/schema/kateschemaconfig.cpp
+++ b/src/schema/kateschemaconfig.cpp
@@ -1,1380 +1,1380 @@
/* This file is part of the KDE libraries
Copyright (C) 2007, 2008 Matthew Woehlke
Copyright (C) 2001-2003 Christoph Cullmann
Copyright (C) 2002, 2003 Anders Lund
Copyright (C) 2012 Dominik Haumann
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Library General Public
* License as published by the Free Software Foundation; either
* version 2 of the License, or (at your option) any later version.
*
* This library 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
* Library General Public License for more details.
*
* You should have received a copy of the GNU Library General Public License
* along with this library; see the file COPYING.LIB. If not, write to
* the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
* Boston, MA 02110-1301, USA.
*/
//BEGIN Includes
#include "kateschemaconfig.h"
#include "katedocument.h"
#include "kateschema.h"
#include "kateconfig.h"
#include "kateglobal.h"
#include "kateview.h"
#include "katerenderer.h"
#include "katestyletreewidget.h"
#include "katecolortreewidget.h"
#include "katepartdebug.h"
#include "katedefaultcolors.h"
#include "ui_howtoimportschema.h"
#include
#include
#include
#include
#include
#include
#include
#include
#include
//END
//BEGIN KateSchemaConfigColorTab -- 'Colors' tab
KateSchemaConfigColorTab::KateSchemaConfigColorTab()
{
QGridLayout *l = new QGridLayout(this);
setLayout(l);
ui = new KateColorTreeWidget(this);
QPushButton *btnUseColorScheme = new QPushButton(i18n("Use KDE Color Scheme"), this);
l->addWidget(ui, 0, 0, 1, 2);
l->addWidget(btnUseColorScheme, 1, 1);
l->setColumnStretch(0, 1);
l->setColumnStretch(1, 0);
connect(btnUseColorScheme, SIGNAL(clicked()), ui, SLOT(selectDefaults()));
connect(ui, SIGNAL(changed()), SIGNAL(changed()));
}
KateSchemaConfigColorTab::~KateSchemaConfigColorTab()
{
}
QVector KateSchemaConfigColorTab::colorItemList() const
{
QVector items;
// use global color instance, creation is expensive!
const KateDefaultColors &colors(KTextEditor::EditorPrivate::self()->defaultColors());
//
// editor background colors
//
KateColorItem ci;
ci.category = i18n("Editor Background Colors");
ci.name = i18n("Text Area");
ci.key = QStringLiteral("Color Background");
ci.whatsThis = i18n("Sets the background color of the editing area.
");
ci.defaultColor = colors.color(Kate::Background);
items.append(ci);
ci.name = i18n("Selected Text");
ci.key = QStringLiteral("Color Selection");
ci.whatsThis = i18n("Sets the background color of the selection.
To set the text color for selected text, use the "Configure Highlighting" dialog.
");
ci.defaultColor = colors.color(Kate::SelectionBackground);
items.append(ci);
ci.name = i18n("Current Line");
ci.key = QStringLiteral("Color Highlighted Line");
ci.whatsThis = i18n("Sets the background color of the currently active line, which means the line where your cursor is positioned.
");
ci.defaultColor = colors.color(Kate::HighlightedLineBackground);
items.append(ci);
ci.name = i18n("Search Highlight");
ci.key = QStringLiteral("Color Search Highlight");
ci.whatsThis = i18n("Sets the background color of search results.
");
ci.defaultColor = colors.color(Kate::SearchHighlight);
items.append(ci);
ci.name = i18n("Replace Highlight");
ci.key = QStringLiteral("Color Replace Highlight");
ci.whatsThis = i18n("Sets the background color of replaced text.
");
ci.defaultColor = colors.color(Kate::ReplaceHighlight);
items.append(ci);
//
// icon border
//
ci.category = i18n("Icon Border");
ci.name = i18n("Background Area");
ci.key = QStringLiteral("Color Icon Bar");
ci.whatsThis = i18n("Sets the background color of the icon border.
");
ci.defaultColor = colors.color(Kate::IconBar);
items.append(ci);
ci.name = i18n("Line Numbers");
ci.key = QStringLiteral("Color Line Number");
ci.whatsThis = i18n("This color will be used to draw the line numbers (if enabled).
");
ci.defaultColor = colors.color(Kate::LineNumber);
items.append(ci);
ci.name = i18n("Current Line Number");
ci.key = QStringLiteral("Color Current Line Number");
ci.whatsThis = i18n("This color will be used to draw the number of the current line (if enabled).
");
ci.defaultColor = colors.color(Kate::CurrentLineNumber);
items.append(ci);
ci.name = i18n("Separator");
ci.key = QStringLiteral("Color Separator");
ci.whatsThis = i18n("This color will be used to draw the line between line numbers and the icon borders, if both are enabled.
");
ci.defaultColor = colors.color(Kate::Separator);
items.append(ci);
ci.name = i18n("Word Wrap Marker");
ci.key = QStringLiteral("Color Word Wrap Marker");
ci.whatsThis = i18n("Sets the color of Word Wrap-related markers:
- Static Word Wrap
- A vertical line which shows the column where text is going to be wrapped
- Dynamic Word Wrap
- An arrow shown to the left of visually-wrapped lines
");
ci.defaultColor = colors.color(Kate::WordWrapMarker);
items.append(ci);
ci.name = i18n("Code Folding");
ci.key = QStringLiteral("Color Code Folding");
ci.whatsThis = i18n("Sets the color of the code folding bar.
");
ci.defaultColor = colors.color(Kate::CodeFolding);
items.append(ci);
ci.name = i18n("Modified Lines");
ci.key = QStringLiteral("Color Modified Lines");
ci.whatsThis = i18n("Sets the color of the line modification marker for modified lines.
");
ci.defaultColor = colors.color(Kate::ModifiedLine);
items.append(ci);
ci.name = i18n("Saved Lines");
ci.key = QStringLiteral("Color Saved Lines");
ci.whatsThis = i18n("Sets the color of the line modification marker for saved lines.
");
ci.defaultColor = colors.color(Kate::SavedLine);
items.append(ci);
//
// text decorations
//
ci.category = i18n("Text Decorations");
ci.name = i18n("Spelling Mistake Line");
ci.key = QStringLiteral("Color Spelling Mistake Line");
ci.whatsThis = i18n("Sets the color of the line that is used to indicate spelling mistakes.
");
ci.defaultColor = colors.color(Kate::SpellingMistakeLine);
items.append(ci);
ci.name = i18n("Tab and Space Markers");
ci.key = QStringLiteral("Color Tab Marker");
ci.whatsThis = i18n("Sets the color of the tabulator marks.
");
ci.defaultColor = colors.color(Kate::TabMarker);
items.append(ci);
ci.name = i18n("Indentation Line");
ci.key = QStringLiteral("Color Indentation Line");
ci.whatsThis = i18n("Sets the color of the vertical indentation lines.
");
ci.defaultColor = colors.color(Kate::IndentationLine);
items.append(ci);
ci.name = i18n("Bracket Highlight");
ci.key = QStringLiteral("Color Highlighted Bracket");
ci.whatsThis = i18n("Sets the bracket matching color. This means, if you place the cursor e.g. at a (, the matching ) will be highlighted with this color.
");
ci.defaultColor = colors.color(Kate::HighlightedBracket);
items.append(ci);
//
// marker colors
//
ci.category = i18n("Marker Colors");
const QString markerNames[Kate::LAST_MARK + 1] = {
i18n("Bookmark"),
i18n("Active Breakpoint"),
i18n("Reached Breakpoint"),
i18n("Disabled Breakpoint"),
i18n("Execution"),
i18n("Warning"),
i18n("Error")
};
ci.whatsThis = i18n("Sets the background color of mark type.
Note: The marker color is displayed lightly because of transparency.
");
for (int i = Kate::FIRST_MARK; i <= Kate::LAST_MARK; ++i) {
ci.defaultColor = colors.mark(i);
ci.name = markerNames[i];
ci.key = QLatin1String("Color MarkType ") + QString::number(i + 1);
items.append(ci);
}
//
// text templates
//
ci.category = i18n("Text Templates & Snippets");
ci.whatsThis = QString(); // TODO: add whatsThis for text templates
ci.name = i18n("Background");
ci.key = QStringLiteral("Color Template Background");
ci.defaultColor = colors.color(Kate::TemplateBackground);
items.append(ci);
ci.name = i18n("Editable Placeholder");
ci.key = QStringLiteral("Color Template Editable Placeholder");
ci.defaultColor = colors.color(Kate::TemplateEditablePlaceholder);
items.append(ci);
ci.name = i18n("Focused Editable Placeholder");
ci.key = QStringLiteral("Color Template Focused Editable Placeholder");
ci.defaultColor = colors.color(Kate::TemplateFocusedEditablePlaceholder);
items.append(ci);
ci.name = i18n("Not Editable Placeholder");
ci.key = QStringLiteral("Color Template Not Editable Placeholder");
ci.defaultColor = colors.color(Kate::TemplateNotEditablePlaceholder);
items.append(ci);
//
// finally, add all elements
//
return items;
}
void KateSchemaConfigColorTab::schemaChanged(const QString &newSchema)
{
// save curent schema
if (!m_currentSchema.isEmpty()) {
if (m_schemas.contains(m_currentSchema)) {
m_schemas.remove(m_currentSchema); // clear this color schema
}
// now add it again
m_schemas[m_currentSchema] = ui->colorItems();
}
if (newSchema == m_currentSchema) {
return;
}
// switch
m_currentSchema = newSchema;
// If we havent this schema, read in from config file
if (! m_schemas.contains(newSchema)) {
KConfigGroup config = KTextEditor::EditorPrivate::self()->schemaManager()->schema(newSchema);
QVector items = readConfig(config);
m_schemas[ newSchema ] = items;
}
// first block signals otherwise setColor emits changed
const bool blocked = blockSignals(true);
ui->clear();
ui->addColorItems(m_schemas[m_currentSchema]);
blockSignals(blocked);
}
QVector KateSchemaConfigColorTab::readConfig(KConfigGroup &config)
{
QVector items = colorItemList();
for (int i = 0; i < items.count(); ++i) {
KateColorItem &item(items[i]);
item.useDefault = !config.hasKey(item.key);
if (item.useDefault) {
item.color = item.defaultColor;
} else {
item.color = config.readEntry(item.key, item.defaultColor);
if (!item.color.isValid()) {
config.deleteEntry(item.key);
item.useDefault = true;
item.color = item.defaultColor;
}
}
}
return items;
}
void KateSchemaConfigColorTab::importSchema(KConfigGroup &config)
{
m_schemas[m_currentSchema] = readConfig(config);
// first block signals otherwise setColor emits changed
const bool blocked = blockSignals(true);
ui->clear();
ui->addColorItems(m_schemas[m_currentSchema]);
blockSignals(blocked);
}
void KateSchemaConfigColorTab::exportSchema(KConfigGroup &config)
{
QVector items = ui->colorItems();
foreach (const KateColorItem &item, items) {
QColor c = item.useDefault ? item.defaultColor : item.color;
config.writeEntry(item.key, c);
}
}
void KateSchemaConfigColorTab::apply()
{
schemaChanged(m_currentSchema);
QMap >::Iterator it;
for (it = m_schemas.begin(); it != m_schemas.end(); ++it) {
KConfigGroup config = KTextEditor::EditorPrivate::self()->schemaManager()->schema(it.key());
foreach (const KateColorItem &item, m_schemas[it.key()]) {
if (item.useDefault) {
config.deleteEntry(item.key);
} else {
config.writeEntry(item.key, item.color);
}
}
// add dummy entry to prevent the config group from being empty.
// As if the group is empty, KateSchemaManager will not find it anymore.
config.writeEntry("dummy", "prevent-empty-group");
}
// all colors are written, so throw away all cached schemas
m_schemas.clear();
}
void KateSchemaConfigColorTab::reload()
{
// drop all cached data
m_schemas.clear();
// load from config
KConfigGroup config = KTextEditor::EditorPrivate::self()->schemaManager()->schema(m_currentSchema);
QVector items = readConfig(config);
// first block signals otherwise setColor emits changed
const bool blocked = blockSignals(true);
ui->clear();
ui->addColorItems(items);
blockSignals(blocked);
}
QColor KateSchemaConfigColorTab::backgroundColor() const
{
return ui->findColor(QStringLiteral("Color Background"));
}
QColor KateSchemaConfigColorTab::selectionColor() const
{
return ui->findColor(QStringLiteral("Color Selection"));
}
//END KateSchemaConfigColorTab
//BEGIN FontConfig -- 'Fonts' tab
KateSchemaConfigFontTab::KateSchemaConfigFontTab()
{
QGridLayout *grid = new QGridLayout(this);
m_fontchooser = new KFontChooser(this, KFontChooser::NoDisplayFlags);
grid->addWidget(m_fontchooser, 0, 0);
}
KateSchemaConfigFontTab::~KateSchemaConfigFontTab()
{
}
void KateSchemaConfigFontTab::slotFontSelected(const QFont &font)
{
if (!m_currentSchema.isEmpty()) {
m_fonts[m_currentSchema] = font;
emit changed();
}
}
void KateSchemaConfigFontTab::apply()
{
QMap::Iterator it;
for (it = m_fonts.begin(); it != m_fonts.end(); ++it) {
KTextEditor::EditorPrivate::self()->schemaManager()->schema(it.key()).writeEntry("Font", it.value());
}
// all fonts are written, so throw away all cached schemas
m_fonts.clear();
}
void KateSchemaConfigFontTab::reload()
{
// drop all cached data
m_fonts.clear();
// now set current schema font in the font chooser
schemaChanged(m_currentSchema);
}
void KateSchemaConfigFontTab::schemaChanged(const QString &newSchema)
{
m_currentSchema = newSchema;
// reuse font, if cached
QFont newFont(QFontDatabase::systemFont(QFontDatabase::FixedFont));
if (m_fonts.contains(m_currentSchema)) {
newFont = m_fonts[m_currentSchema];
} else {
newFont = KTextEditor::EditorPrivate::self()->schemaManager()->schema(m_currentSchema).readEntry("Font", newFont);
}
m_fontchooser->disconnect(this);
m_fontchooser->setFont(newFont);
connect(m_fontchooser, SIGNAL(fontSelected(QFont)), this, SLOT(slotFontSelected(QFont)));
}
void KateSchemaConfigFontTab::importSchema(KConfigGroup &config)
{
QFont f(QFontDatabase::systemFont(QFontDatabase::FixedFont));
m_fontchooser->setFont(config.readEntry("Font", f));
m_fonts[m_currentSchema] = m_fontchooser->font();
}
void KateSchemaConfigFontTab::exportSchema(KConfigGroup &config)
{
config.writeEntry("Font", m_fontchooser->font());
}
//END FontConfig
//BEGIN FontColorConfig -- 'Normal Text Styles' tab
KateSchemaConfigDefaultStylesTab::KateSchemaConfigDefaultStylesTab(KateSchemaConfigColorTab *colorTab)
{
m_colorTab = colorTab;
// size management
QGridLayout *grid = new QGridLayout(this);
m_defaultStyles = new KateStyleTreeWidget(this);
connect(m_defaultStyles, SIGNAL(changed()), this, SIGNAL(changed()));
grid->addWidget(m_defaultStyles, 0, 0);
m_defaultStyles->setWhatsThis(i18n(
"This list displays the default styles for the current schema and "
"offers the means to edit them. The style name reflects the current "
"style settings.
"
"To edit the colors, click the colored squares, or select the color "
"to edit from the popup menu.
You can unset the Background and Selected "
"Background colors from the popup menu when appropriate.
"));
}
KateSchemaConfigDefaultStylesTab::~KateSchemaConfigDefaultStylesTab()
{
qDeleteAll(m_defaultStyleLists);
}
KateAttributeList *KateSchemaConfigDefaultStylesTab::attributeList(const QString &schema)
{
if (!m_defaultStyleLists.contains(schema)) {
KateAttributeList *list = new KateAttributeList();
KateHlManager::self()->getDefaults(schema, *list);
m_defaultStyleLists.insert(schema, list);
}
return m_defaultStyleLists[schema];
}
void KateSchemaConfigDefaultStylesTab::schemaChanged(const QString &schema)
{
m_currentSchema = schema;
m_defaultStyles->clear();
KateAttributeList *l = attributeList(schema);
updateColorPalette(l->at(0)->foreground().color());
// normal text and source code
QTreeWidgetItem *parent = new QTreeWidgetItem(m_defaultStyles, QStringList() << i18nc("@item:intable", "Normal Text & Source Code"));
parent->setFirstColumnSpanned(true);
for (int i = (int)KTextEditor::dsNormal;
i <= (int)KTextEditor::dsAttribute; ++i)
{
m_defaultStyles->addItem(parent, KateHlManager::self()->defaultStyleName(i, true), l->at(i));
}
// Number, Types & Constants
parent = new QTreeWidgetItem(m_defaultStyles, QStringList() << i18nc("@item:intable", "Numbers, Types & Constants"));
parent->setFirstColumnSpanned(true);
for (int i = (int)KTextEditor::dsDataType;
i <= (int)KTextEditor::dsConstant; ++i)
{
m_defaultStyles->addItem(parent, KateHlManager::self()->defaultStyleName(i, true), l->at(i));
}
// strings & characters
parent = new QTreeWidgetItem(m_defaultStyles, QStringList() << i18nc("@item:intable", "Strings & Characters"));
parent->setFirstColumnSpanned(true);
for (int i = (int)KTextEditor::dsChar;
i <= (int)KTextEditor::dsImport; ++i)
{
m_defaultStyles->addItem(parent, KateHlManager::self()->defaultStyleName(i, true), l->at(i));
}
// comments & documentation
parent = new QTreeWidgetItem(m_defaultStyles, QStringList() << i18nc("@item:intable", "Comments & Documentation"));
parent->setFirstColumnSpanned(true);
for (int i = (int)KTextEditor::dsComment;
i <= (int)KTextEditor::dsAlert; ++i)
{
m_defaultStyles->addItem(parent, KateHlManager::self()->defaultStyleName(i, true), l->at(i));
}
// Misc
parent = new QTreeWidgetItem(m_defaultStyles, QStringList() << i18nc("@item:intable", "Miscellaneous"));
parent->setFirstColumnSpanned(true);
for (int i = (int)KTextEditor::dsOthers;
i <= (int)KTextEditor::dsError; ++i)
{
m_defaultStyles->addItem(parent, KateHlManager::self()->defaultStyleName(i, true), l->at(i));
}
m_defaultStyles->expandAll();
}
void KateSchemaConfigDefaultStylesTab::updateColorPalette(const QColor &textColor)
{
QPalette p(m_defaultStyles->palette());
p.setColor(QPalette::Base, m_colorTab->backgroundColor());
p.setColor(QPalette::Highlight, m_colorTab->selectionColor());
p.setColor(QPalette::Text, textColor);
m_defaultStyles->setPalette(p);
}
void KateSchemaConfigDefaultStylesTab::reload()
{
m_defaultStyles->clear();
qDeleteAll(m_defaultStyleLists);
m_defaultStyleLists.clear();
schemaChanged(m_currentSchema);
}
void KateSchemaConfigDefaultStylesTab::apply()
{
QHashIterator it = m_defaultStyleLists;
while (it.hasNext()) {
it.next();
KateHlManager::self()->setDefaults(it.key(), *it.value());
}
}
void KateSchemaConfigDefaultStylesTab::exportSchema(const QString &schema, KConfig *cfg)
{
KateHlManager::self()->setDefaults(schema, *(m_defaultStyleLists[schema]), cfg);
}
void KateSchemaConfigDefaultStylesTab::importSchema(const QString &schemaName, const QString &schema, KConfig *cfg)
{
KateHlManager::self()->getDefaults(schemaName, *(m_defaultStyleLists[schema]), cfg);
}
void KateSchemaConfigDefaultStylesTab::showEvent(QShowEvent *event)
{
if (!event->spontaneous() && !m_currentSchema.isEmpty()) {
KateAttributeList *l = attributeList(m_currentSchema);
Q_ASSERT(l != nullptr);
updateColorPalette(l->at(0)->foreground().color());
}
QWidget::showEvent(event);
}
//END FontColorConfig
//BEGIN KateSchemaConfigHighlightTab -- 'Highlighting Text Styles' tab
KateSchemaConfigHighlightTab::KateSchemaConfigHighlightTab(KateSchemaConfigDefaultStylesTab *page, KateSchemaConfigColorTab *colorTab)
{
m_defaults = page;
m_colorTab = colorTab;
m_hl = 0;
QVBoxLayout *layout = new QVBoxLayout(this);
QHBoxLayout *headerLayout = new QHBoxLayout;
layout->addLayout(headerLayout);
QLabel *lHl = new QLabel(i18n("H&ighlight:"), this);
headerLayout->addWidget(lHl);
hlCombo = new KComboBox(this);
hlCombo->setEditable(false);
headerLayout->addWidget(hlCombo);
lHl->setBuddy(hlCombo);
connect(hlCombo, SIGNAL(activated(int)), this, SLOT(hlChanged(int)));
QPushButton *btnexport = new QPushButton(i18n("Export..."), this);
headerLayout->addWidget(btnexport);
connect(btnexport, SIGNAL(clicked()), this, SLOT(exportHl()));
QPushButton *btnimport = new QPushButton(i18n("Import..."), this);
headerLayout->addWidget(btnimport);
connect(btnimport, SIGNAL(clicked()), this, SLOT(importHl()));
headerLayout->addStretch();
- for (int i = 0; i < KateHlManager::self()->highlights(); i++) {
- if (KateHlManager::self()->hlSection(i).length() > 0) {
- hlCombo->addItem(KateHlManager::self()->hlSection(i) + QLatin1String("/") + KateHlManager::self()->hlNameTranslated(i));
+ for (const auto &hl : KateHlManager::self()->modeList()) {
+ if (hl.section().length() > 0) {
+ hlCombo->addItem(hl.section() + QLatin1String("/") + hl.translatedName());
} else {
- hlCombo->addItem(KateHlManager::self()->hlNameTranslated(i));
+ hlCombo->addItem(hl.translatedName());
}
}
hlCombo->setCurrentIndex(0);
// styles listview
m_styles = new KateStyleTreeWidget(this, true);
connect(m_styles, SIGNAL(changed()), this, SIGNAL(changed()));
layout->addWidget(m_styles, 999);
// get current highlighting from the host application
int hl = 0;
KTextEditor::ViewPrivate *kv = qobject_cast(KTextEditor::EditorPrivate::self()->application()->activeMainWindow()->activeView());
if (kv) {
const QString hlName = kv->doc()->highlight()->name();
hl = KateHlManager::self()->nameFind(hlName);
Q_ASSERT(hl >= 0);
}
hlCombo->setCurrentIndex(hl);
hlChanged(hl);
m_styles->setWhatsThis(i18n(
"This list displays the contexts of the current syntax highlight mode and "
"offers the means to edit them. The context name reflects the current "
"style settings.
To edit using the keyboard, press "
"<SPACE> and choose a property from the popup menu.
"
"To edit the colors, click the colored squares, or select the color "
"to edit from the popup menu.
You can unset the Background and Selected "
"Background colors from the context menu when appropriate.
"));
}
KateSchemaConfigHighlightTab::~KateSchemaConfigHighlightTab()
{
}
void KateSchemaConfigHighlightTab::hlChanged(int z)
{
m_hl = z;
schemaChanged(m_schema);
}
bool KateSchemaConfigHighlightTab::loadAllHlsForSchema(const QString &schema)
{
- QProgressDialog progress(i18n("Loading all highlightings for schema"), QString(), 0, KateHlManager::self()->highlights(), this);
+ QProgressDialog progress(i18n("Loading all highlightings for schema"), QString(), 0, KateHlManager::self()->modeList().size(), this);
progress.setWindowModality(Qt::WindowModal);
- for (int i = 0; i < KateHlManager::self()->highlights(); ++i) {
+ for (int i = 0; i < KateHlManager::self()->modeList().size(); ++i) {
if (!m_hlDict[schema].contains(i)) {
QList list;
KateHlManager::self()->getHl(i)->getKateExtendedAttributeListCopy(schema, list);
m_hlDict[schema].insert(i, list);
}
progress.setValue(progress.value() + 1);
}
- progress.setValue(KateHlManager::self()->highlights());
+ progress.setValue(KateHlManager::self()->modeList().size());
return true;
}
void KateSchemaConfigHighlightTab::schemaChanged(const QString &schema)
{
m_schema = schema;
m_styles->clear();
if (!m_hlDict.contains(m_schema)) {
m_hlDict.insert(schema, QHash >());
}
if (!m_hlDict[m_schema].contains(m_hl)) {
QList list;
KateHlManager::self()->getHl(m_hl)->getKateExtendedAttributeListCopy(m_schema, list);
m_hlDict[m_schema].insert(m_hl, list);
}
KateAttributeList *l = m_defaults->attributeList(schema);
// Set listview colors
updateColorPalette(l->at(0)->foreground().color());
QHash prefixes;
QList::ConstIterator it = m_hlDict[m_schema][m_hl].constBegin();
while (it != m_hlDict[m_schema][m_hl].constEnd()) {
const KTextEditor::Attribute::Ptr itemData = *it;
Q_ASSERT(itemData);
// All stylenames have their language mode prefixed, e.g. HTML:Comment
// split them and put them into nice substructures.
int c = itemData->name().indexOf(QLatin1Char(':'));
if (c > 0) {
QString prefix = itemData->name().left(c);
QString name = itemData->name().mid(c + 1);
QTreeWidgetItem *parent = prefixes[prefix];
if (! parent) {
parent = new QTreeWidgetItem(m_styles, QStringList() << prefix);
m_styles->expandItem(parent);
prefixes.insert(prefix, parent);
}
m_styles->addItem(parent, name, l->at(itemData->defaultStyle()), itemData);
} else {
m_styles->addItem(itemData->name(), l->at(itemData->defaultStyle()), itemData);
}
++it;
}
m_styles->resizeColumns();
}
void KateSchemaConfigHighlightTab::updateColorPalette(const QColor &textColor)
{
QPalette p(m_styles->palette());
p.setColor(QPalette::Base, m_colorTab->backgroundColor());
p.setColor(QPalette::Highlight, m_colorTab->selectionColor());
p.setColor(QPalette::Text, textColor);
m_styles->setPalette(p);
}
void KateSchemaConfigHighlightTab::reload()
{
m_styles->clear();
m_hlDict.clear();
hlChanged(hlCombo->currentIndex());
}
void KateSchemaConfigHighlightTab::apply()
{
QMutableHashIterator > > it = m_hlDict;
while (it.hasNext()) {
it.next();
QMutableHashIterator > it2 = it.value();
while (it2.hasNext()) {
it2.next();
KateHlManager::self()->getHl(it2.key())->setKateExtendedAttributeList(it.key(), it2.value());
}
}
}
QList KateSchemaConfigHighlightTab::hlsForSchema(const QString &schema)
{
return m_hlDict[schema].keys();
}
void KateSchemaConfigHighlightTab::importHl(const QString &fromSchemaName, QString schema, int hl, KConfig *cfg)
{
QString schemaNameForLoading(fromSchemaName);
QString hlName;
bool doManage = (cfg == nullptr);
if (schema.isEmpty()) {
schema = m_schema;
}
if (doManage) {
QString srcName = QFileDialog::getOpenFileName(this,
i18n("Importing colors for single highlighting"),
KateHlManager::self()->getHl(hl)->name() + QLatin1String(".katehlcolor"),
QStringLiteral("%1 (*.katehlcolor)").arg(i18n("Kate color schema")));
if (srcName.isEmpty()) {
return;
}
cfg = new KConfig(srcName, KConfig::SimpleConfig);
KConfigGroup grp(cfg, "KateHLColors");
hlName = grp.readEntry("highlight", QString());
schemaNameForLoading = grp.readEntry("schema", QString());
if ((grp.readEntry("full schema", "true").toUpper() != QLatin1String("FALSE")) || hlName.isEmpty() || schemaNameForLoading.isEmpty()) {
//ERROR - file format
KMessageBox::information(
this,
i18n("File is not a single highlighting color file"),
i18n("Fileformat error"));
hl = -1;
schemaNameForLoading = QString();
} else {
hl = KateHlManager::self()->nameFind(hlName);
if (hl == -1) {
//hl not found
KMessageBox::information(
this,
i18n("The selected file contains colors for a non existing highlighting:%1", hlName),
i18n("Import failure"));
hl = -1;
schemaNameForLoading = QString();
}
}
}
if ((hl != -1) && (!schemaNameForLoading.isEmpty())) {
QList list;
KateHlManager::self()->getHl(hl)->getKateExtendedAttributeListCopy(schemaNameForLoading, list, cfg);
KateHlManager::self()->getHl(hl)->setKateExtendedAttributeList(schema, list);
m_hlDict[schema].insert(hl, list);
}
if (cfg && doManage) {
apply();
delete cfg;
cfg = nullptr;
if ((hl != -1) && (!schemaNameForLoading.isEmpty())) {
hlChanged(m_hl);
KMessageBox::information(
this,
i18n("Colors have been imported for highlighting: %1", hlName),
i18n("Import has finished"));
}
}
}
void KateSchemaConfigHighlightTab::exportHl(QString schema, int hl, KConfig *cfg)
{
bool doManage = (cfg == nullptr);
if (schema.isEmpty()) {
schema = m_schema;
}
if (hl == -1) {
hl = m_hl;
}
QList items = m_hlDict[schema][hl];
if (doManage) {
QString destName = QFileDialog::getSaveFileName(this,
i18n("Exporting colors for single highlighting: %1", KateHlManager::self()->getHl(hl)->name()),
KateHlManager::self()->getHl(hl)->name() + QLatin1String(".katehlcolor"),
QStringLiteral("%1 (*.katehlcolor)").arg(i18n("Kate color schema")));
if (destName.isEmpty()) {
return;
}
cfg = new KConfig(destName, KConfig::SimpleConfig);
KConfigGroup grp(cfg, "KateHLColors");
grp.writeEntry("highlight", KateHlManager::self()->getHl(hl)->name());
grp.writeEntry("schema", schema);
grp.writeEntry("full schema", "false");
}
KateHlManager::self()->getHl(hl)->setKateExtendedAttributeList(schema, items, cfg, doManage);
if (doManage) {
cfg->sync();
delete cfg;
}
}
void KateSchemaConfigHighlightTab::showEvent(QShowEvent *event)
{
if (!event->spontaneous()) {
KateAttributeList *l = m_defaults->attributeList(m_schema);
Q_ASSERT(l != nullptr);
updateColorPalette(l->at(0)->foreground().color());
}
QWidget::showEvent(event);
}
//END KateSchemaConfigHighlightTab
//BEGIN KateSchemaConfigPage -- Main dialog page
KateSchemaConfigPage::KateSchemaConfigPage(QWidget *parent)
: KateConfigPage(parent),
m_currentSchema(-1)
{
QVBoxLayout *layout = new QVBoxLayout(this);
layout->setMargin(0);
// header
QHBoxLayout *headerLayout = new QHBoxLayout;
layout->addLayout(headerLayout);
QLabel *lHl = new QLabel(i18n("&Schema:"), this);
headerLayout->addWidget(lHl);
schemaCombo = new KComboBox(this);
schemaCombo->setEditable(false);
lHl->setBuddy(schemaCombo);
headerLayout->addWidget(schemaCombo);
connect(schemaCombo, SIGNAL(currentIndexChanged(int)), this, SLOT(comboBoxIndexChanged(int)));
QPushButton *btnnew = new QPushButton(i18n("&New..."), this);
headerLayout->addWidget(btnnew);
connect(btnnew, SIGNAL(clicked()), this, SLOT(newSchema()));
btndel = new QPushButton(i18n("&Delete"), this);
headerLayout->addWidget(btndel);
connect(btndel, SIGNAL(clicked()), this, SLOT(deleteSchema()));
QPushButton *btnexport = new QPushButton(i18n("Export..."), this);
headerLayout->addWidget(btnexport);
connect(btnexport, SIGNAL(clicked()), this, SLOT(exportFullSchema()));
QPushButton *btnimport = new QPushButton(i18n("Import..."), this);
headerLayout->addWidget(btnimport);
connect(btnimport, SIGNAL(clicked()), this, SLOT(importFullSchema()));
headerLayout->addStretch();
// tabs
QTabWidget *tabWidget = new QTabWidget(this);
layout->addWidget(tabWidget);
m_colorTab = new KateSchemaConfigColorTab();
tabWidget->addTab(m_colorTab, i18n("Colors"));
connect(m_colorTab, SIGNAL(changed()), SLOT(slotChanged()));
m_fontTab = new KateSchemaConfigFontTab();
tabWidget->addTab(m_fontTab, i18n("Font"));
connect(m_fontTab, SIGNAL(changed()), SLOT(slotChanged()));
m_defaultStylesTab = new KateSchemaConfigDefaultStylesTab(m_colorTab);
tabWidget->addTab(m_defaultStylesTab, i18n("Default Text Styles"));
connect(m_defaultStylesTab, SIGNAL(changed()), SLOT(slotChanged()));
m_highlightTab = new KateSchemaConfigHighlightTab(m_defaultStylesTab, m_colorTab);
tabWidget->addTab(m_highlightTab, i18n("Highlighting Text Styles"));
connect(m_highlightTab, SIGNAL(changed()), SLOT(slotChanged()));
QHBoxLayout *footLayout = new QHBoxLayout;
layout->addLayout(footLayout);
lHl = new QLabel(i18n("&Default schema for %1:", QCoreApplication::applicationName()), this);
footLayout->addWidget(lHl);
defaultSchemaCombo = new KComboBox(this);
footLayout->addWidget(defaultSchemaCombo);
defaultSchemaCombo->setEditable(false);
lHl->setBuddy(defaultSchemaCombo);
reload();
connect(defaultSchemaCombo, SIGNAL(currentIndexChanged(int)), this, SLOT(slotChanged()));
}
KateSchemaConfigPage::~KateSchemaConfigPage()
{
}
void KateSchemaConfigPage::exportFullSchema()
{
// get save destination
const QString currentSchemaName = m_currentSchema;
QString destName = QFileDialog::getSaveFileName(this,
i18n("Exporting color schema: %1", currentSchemaName),
currentSchemaName + QLatin1String(".kateschema"),
QStringLiteral("%1 (*.kateschema)").arg(i18n("Kate color schema")));
if (destName.isEmpty()) {
return;
}
// open config file
KConfig cfg(destName, KConfig::SimpleConfig);
//
// export editor Colors (background, ...)
//
KConfigGroup colorConfigGroup(&cfg, "Editor Colors");
m_colorTab->exportSchema(colorConfigGroup);
//
// export Default Styles
//
m_defaultStylesTab->exportSchema(m_currentSchema, &cfg);
//
// export Highlighting Text Styles
//
// force a load of all Highlighting Text Styles
QStringList hlList;
m_highlightTab->loadAllHlsForSchema(m_currentSchema);
QList hls = m_highlightTab->hlsForSchema(m_currentSchema);
int cnt = 0;
QProgressDialog progress(i18n("Exporting schema"), QString(), 0, hls.count(), this);
progress.setWindowModality(Qt::WindowModal);
foreach (int hl, hls) {
hlList << KateHlManager::self()->getHl(hl)->name();
m_highlightTab->exportHl(m_currentSchema, hl, &cfg);
progress.setValue(++cnt);
if (progress.wasCanceled()) {
break;
}
}
progress.setValue(hls.count());
KConfigGroup grp(&cfg, "KateSchema");
grp.writeEntry("full schema", "true");
grp.writeEntry("highlightings", hlList);
grp.writeEntry("schema", currentSchemaName);
m_fontTab->exportSchema(grp);
cfg.sync();
}
QString KateSchemaConfigPage::requestSchemaName(const QString &suggestedName)
{
QString schemaName = suggestedName;
bool reask = true;
do {
QDialog howToImportDialog(this);
Ui_KateHowToImportSchema howToImport;
QVBoxLayout *mainLayout = new QVBoxLayout;
howToImportDialog.setLayout(mainLayout);
QWidget *w = new QWidget(&howToImportDialog);
mainLayout->addWidget(w);
howToImport.setupUi(w);
QDialogButtonBox *buttons = new QDialogButtonBox(&howToImportDialog);
mainLayout->addWidget(buttons);
QPushButton *okButton = new QPushButton;
okButton->setDefault(true);
KGuiItem::assign(okButton, KStandardGuiItem::ok());
buttons->addButton(okButton, QDialogButtonBox::AcceptRole);
connect(okButton, SIGNAL(clicked()), &howToImportDialog, SLOT(accept()));
QPushButton *cancelButton = new QPushButton;
KGuiItem::assign(cancelButton, KStandardGuiItem::cancel());
buttons->addButton(cancelButton, QDialogButtonBox::RejectRole);
connect(cancelButton, SIGNAL(clicked()), &howToImportDialog, SLOT(reject()));
//
// if schema exists, prepare option to replace
if (KTextEditor::EditorPrivate::self()->schemaManager()->schema(schemaName).exists()) {
howToImport.radioReplaceExisting->show();
howToImport.radioReplaceExisting->setText(i18n("Replace existing schema %1", schemaName));
howToImport.radioReplaceExisting->setChecked(true);
} else {
howToImport.radioReplaceExisting->hide();
howToImport.newName->setText(schemaName);
}
// cancel pressed?
if (howToImportDialog.exec() == QDialog::Rejected) {
schemaName.clear();
reask = false;
}
// check what the user wants
else {
// replace existing
if (howToImport.radioReplaceExisting->isChecked()) {
reask = false;
}
// replace current
else if (howToImport.radioReplaceCurrent->isChecked()) {
schemaName = m_currentSchema;
reask = false;
}
// new one, check again, whether the schema already exists
else if (howToImport.radioAsNew->isChecked()) {
schemaName = howToImport.newName->text();
if (KTextEditor::EditorPrivate::self()->schemaManager()->schema(schemaName).exists()) {
reask = true;
} else {
reask = false;
}
}
// should never happen
else {
reask = true;
}
}
} while (reask);
return schemaName;
}
void KateSchemaConfigPage::importFullSchema()
{
const QString srcName = QFileDialog::getOpenFileName(this,
i18n("Importing Color Schema"),
QString(),
QStringLiteral("%1 (*.kateschema)").arg(i18n("Kate color schema")));
if (srcName.isEmpty()) {
return;
}
// carete config + sanity check for full color schema
KConfig cfg(srcName, KConfig::SimpleConfig);
KConfigGroup schemaGroup(&cfg, "KateSchema");
if (schemaGroup.readEntry("full schema", "false").toUpper() != QLatin1String("TRUE")) {
KMessageBox::sorry(this, i18n("The file does not contain a full color schema."),
i18n("Fileformat error"));
return;
}
// read color schema name
const QStringList highlightings = schemaGroup.readEntry("highlightings", QStringList());
const QString fromSchemaName = schemaGroup.readEntry("schema", i18n("Name unspecified"));
// request valid schema name
const QString schemaName = requestSchemaName(fromSchemaName);
if (schemaName.isEmpty()) {
return;
}
// if the schema already exists, select it in the combo box
if (schemaCombo->findData(schemaName) != -1) {
schemaCombo->setCurrentIndex(schemaCombo->findData(schemaName));
} else { // it is really a new schema, easy meat :-)
newSchema(schemaName);
}
// make sure the correct schema is activated
schemaChanged(schemaName);
// Finally, the correct schema is activated.
// Next, start importing.
//
// import editor Colors (background, ...)
//
KConfigGroup colorConfigGroup(&cfg, "Editor Colors");
m_colorTab->importSchema(colorConfigGroup);
//
// import font
//
m_fontTab->importSchema(schemaGroup);
//
// import Default Styles
//
m_defaultStylesTab->importSchema(fromSchemaName, schemaName, &cfg);
//
// import all Highlighting Text Styles
//
// create mapping from highlighting name to internal id
- const int hlCount = KateHlManager::self()->highlights();
+ const int hlCount = KateHlManager::self()->modeList().size();
QHash nameToId;
for (int i = 0; i < hlCount; ++i) {
- nameToId.insert(KateHlManager::self()->hlName(i), i);
+ nameToId.insert(KateHlManager::self()->modeList().at(i).name(), i);
}
// may take some time, as we have > 200 highlightings
int cnt = 0;
QProgressDialog progress(i18n("Importing schema"), QString(), 0, highlightings.count(), this);
progress.setWindowModality(Qt::WindowModal);
foreach (const QString &hl, highlightings) {
if (nameToId.contains(hl)) {
const int i = nameToId[hl];
m_highlightTab->importHl(fromSchemaName, schemaName, i, &cfg);
}
progress.setValue(++cnt);
}
progress.setValue(highlightings.count());
}
void KateSchemaConfigPage::apply()
{
// remember name + index
const QString schemaName = schemaCombo->itemData(schemaCombo->currentIndex()).toString();
// first apply all tabs
m_colorTab->apply();
m_fontTab->apply();
m_defaultStylesTab->apply();
m_highlightTab->apply();
// just sync the config and reload
KTextEditor::EditorPrivate::self()->schemaManager()->config().sync();
KTextEditor::EditorPrivate::self()->schemaManager()->config().reparseConfiguration();
// clear all attributes
- for (int i = 0; i < KateHlManager::self()->highlights(); ++i) {
+ for (int i = 0; i < KateHlManager::self()->modeList().size(); ++i) {
KateHlManager::self()->getHl(i)->clearAttributeArrays();
}
// than reload the whole stuff
KateRendererConfig::global()->setSchema(defaultSchemaCombo->itemData(defaultSchemaCombo->currentIndex()).toString());
KateRendererConfig::global()->reloadSchema();
// sync the hl config for real
KateHlManager::self()->getKConfig()->sync();
// KateSchemaManager::update() sorts the schema alphabetically, hence the
// schema indexes change. Thus, repopulate the schema list...
refillCombos(schemaCombo->itemData(schemaCombo->currentIndex()).toString(), defaultSchemaCombo->itemData(defaultSchemaCombo->currentIndex()).toString());
schemaChanged(schemaName);
}
void KateSchemaConfigPage::reload()
{
// now reload the config from disc
KTextEditor::EditorPrivate::self()->schemaManager()->config().reparseConfiguration();
// reinitialize combo boxes
refillCombos(KateRendererConfig::global()->schema(), KateRendererConfig::global()->schema());
// finally, activate the current schema again
schemaChanged(schemaCombo->itemData(schemaCombo->currentIndex()).toString());
// all tabs need to reload to discard all the cached data, as the index
// mapping may have changed
m_colorTab->reload();
m_fontTab->reload();
m_defaultStylesTab->reload();
m_highlightTab->reload();
}
void KateSchemaConfigPage::refillCombos(const QString &schemaName, const QString &defaultSchemaName)
{
schemaCombo->blockSignals(true);
defaultSchemaCombo->blockSignals(true);
// reinitialize combo boxes
schemaCombo->clear();
defaultSchemaCombo->clear();
QList schemaList = KTextEditor::EditorPrivate::self()->schemaManager()->list();
foreach (const KateSchema &s, schemaList) {
schemaCombo->addItem(s.translatedName(), s.rawName);
defaultSchemaCombo->addItem(s.translatedName(), s.rawName);
}
// set the correct indexes again, fallback to always existing "Normal"
int schemaIndex = schemaCombo->findData(schemaName);
if (schemaIndex == -1) {
schemaIndex = schemaCombo->findData(QLatin1String("Normal"));
}
int defaultSchemaIndex = defaultSchemaCombo->findData(defaultSchemaName);
if (defaultSchemaIndex == -1) {
defaultSchemaIndex = defaultSchemaCombo->findData(QLatin1String("Normal"));
}
Q_ASSERT(schemaIndex != -1);
Q_ASSERT(defaultSchemaIndex != -1);
defaultSchemaCombo->setCurrentIndex(defaultSchemaIndex);
schemaCombo->setCurrentIndex(schemaIndex);
schemaCombo->blockSignals(false);
defaultSchemaCombo->blockSignals(false);
}
void KateSchemaConfigPage::reset()
{
reload();
}
void KateSchemaConfigPage::defaults()
{
reload();
}
void KateSchemaConfigPage::deleteSchema()
{
const int comboIndex = schemaCombo->currentIndex();
const QString schemaNameToDelete = schemaCombo->itemData(comboIndex).toString();
if (KTextEditor::EditorPrivate::self()->schemaManager()->schemaData(schemaNameToDelete).shippedDefaultSchema) {
// Default and Printing schema cannot be deleted.
return;
}
// kill group
KTextEditor::EditorPrivate::self()->schemaManager()->config().deleteGroup(schemaNameToDelete);
// fallback to Default schema
schemaCombo->setCurrentIndex(schemaCombo->findData(QVariant(QStringLiteral("Normal"))));
if (defaultSchemaCombo->currentIndex() == defaultSchemaCombo->findData(schemaNameToDelete)) {
defaultSchemaCombo->setCurrentIndex(defaultSchemaCombo->findData(QVariant(QStringLiteral("Normal"))));
}
// remove schema from combo box
schemaCombo->removeItem(comboIndex);
defaultSchemaCombo->removeItem(comboIndex);
// Reload the color tab, since it uses cached schemas
m_colorTab->reload();
}
bool KateSchemaConfigPage::newSchema(const QString &newName)
{
// get sane name
QString schemaName(newName);
if (newName.isEmpty()) {
bool ok = false;
schemaName = QInputDialog::getText(this, i18n("Name for New Schema"), i18n("Name:"), QLineEdit::Normal, i18n("New Schema"), &ok);
if (!ok) {
return false;
}
}
// try if schema already around
if (KTextEditor::EditorPrivate::self()->schemaManager()->schema(schemaName).exists()) {
KMessageBox::information(this, i18n("The schema %1 already exists.
Please choose a different schema name.
", schemaName), i18n("New Schema"));
return false;
}
// append items to combo boxes
schemaCombo->addItem(schemaName, QVariant(schemaName));
defaultSchemaCombo->addItem(schemaName, QVariant(schemaName));
// finally, activate new schema (last item in the list)
schemaCombo->setCurrentIndex(schemaCombo->count() - 1);
return true;
}
void KateSchemaConfigPage::schemaChanged(const QString &schema)
{
btndel->setEnabled(!KTextEditor::EditorPrivate::self()->schemaManager()->schemaData(schema).shippedDefaultSchema);
// propagate changed schema to all tabs
m_colorTab->schemaChanged(schema);
m_fontTab->schemaChanged(schema);
m_defaultStylesTab->schemaChanged(schema);
m_highlightTab->schemaChanged(schema);
// save current schema index
m_currentSchema = schema;
}
void KateSchemaConfigPage::comboBoxIndexChanged(int currentIndex)
{
schemaChanged(schemaCombo->itemData(currentIndex).toString());
}
QString KateSchemaConfigPage::name() const
{
return i18n("Fonts & Colors");
}
QString KateSchemaConfigPage::fullName() const
{
return i18n("Font & Color Schemas");
}
QIcon KateSchemaConfigPage::icon() const
{
return QIcon::fromTheme(QStringLiteral("preferences-desktop-color"));
}
//END KateSchemaConfigPage
diff --git a/src/syntax/katehighlightmenu.cpp b/src/syntax/katehighlightmenu.cpp
index 17a0396c..dd836443 100644
--- a/src/syntax/katehighlightmenu.cpp
+++ b/src/syntax/katehighlightmenu.cpp
@@ -1,106 +1,106 @@
/* This file is part of the KDE libraries
Copyright (C) 2001-2003 Christoph Cullmann
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Library General Public
* License as published by the Free Software Foundation; either
* version 2 of the License, or (at your option) any later version.
*
* This library 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
* Library General Public License for more details.
*
* You should have received a copy of the GNU Library General Public License
* along with this library; see the file COPYING.LIB. If not, write to
* the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
* Boston, MA 02110-1301, USA.
*/
//BEGIN Includes
#include "katehighlightmenu.h"
#include "katedocument.h"
#include "kateconfig.h"
#include "kateview.h"
#include "kateglobal.h"
#include "katesyntaxmanager.h"
#include "katepartdebug.h"
//END Includes
KateHighlightingMenu::~KateHighlightingMenu()
{
qDeleteAll(subMenus);
}
void KateHighlightingMenu::init()
{
m_doc = nullptr;
connect(menu(), SIGNAL(aboutToShow()), this, SLOT(slotAboutToShow()));
m_actionGroup = new QActionGroup(menu());
}
void KateHighlightingMenu::updateMenu(KTextEditor::DocumentPrivate *doc)
{
m_doc = doc;
}
void KateHighlightingMenu::slotAboutToShow()
{
- for (int z = 0; z < KateHlManager::self()->highlights(); z++) {
- QString hlName = KateHlManager::self()->hlNameTranslated(z);
- QString hlSection = KateHlManager::self()->hlSection(z);
+ for (const auto &hl : KateHlManager::self()->modeList()) {
+ QString hlName = hl.translatedName();
+ QString hlSection = hl.section();
- if (!KateHlManager::self()->hlHidden(z)) {
+ if (!hl.isHidden()) {
if (!hlSection.isEmpty() && !names.contains(hlName)) {
if (!subMenusName.contains(hlSection)) {
subMenusName << hlSection;
QMenu *qmenu = new QMenu(QLatin1Char('&') + hlSection);
subMenus.append(qmenu);
menu()->addMenu(qmenu);
}
int m = subMenusName.indexOf(hlSection);
names << hlName;
QAction *a = subMenus.at(m)->addAction(QLatin1Char('&') + hlName, this, SLOT(setHl()));
m_actionGroup->addAction(a);
- a->setData(KateHlManager::self()->hlName(z));
+ a->setData(hl.name());
a->setCheckable(true);
subActions.append(a);
} else if (!names.contains(hlName)) {
names << hlName;
QAction *a = menu()->addAction(QLatin1Char('&') + hlName, this, SLOT(setHl()));
m_actionGroup->addAction(a);
- a->setData(KateHlManager::self()->hlName(z));
+ a->setData(hl.name());
a->setCheckable(true);
subActions.append(a);
}
}
}
if (!m_doc) {
return;
}
QString mode = m_doc->highlightingMode();
for (int i = 0; i < subActions.count(); i++) {
subActions[i]->setChecked(subActions[i]->data().toString() == mode);
}
}
void KateHighlightingMenu::setHl()
{
if (!m_doc || !sender()) {
return;
}
QAction *action = qobject_cast(sender());
if (!action) {
return;
}
QString mode = action->data().toString();
m_doc->setHighlightingMode(mode);
// use change, honor this
m_doc->setDontChangeHlOnSave();
}
diff --git a/src/syntax/katesyntaxmanager.cpp b/src/syntax/katesyntaxmanager.cpp
index 7a775ff6..e095b81d 100644
--- a/src/syntax/katesyntaxmanager.cpp
+++ b/src/syntax/katesyntaxmanager.cpp
@@ -1,676 +1,651 @@
/* This file is part of the KDE libraries
Copyright (C) 2007 Matthew Woehlke
Copyright (C) 2003, 2004 Anders Lund
Copyright (C) 2003 Hamish Rodda
Copyright (C) 2001,2002 Joseph Wenninger
Copyright (C) 2001 Christoph Cullmann
Copyright (C) 1999 Jochen Wilhelmy
This library is free software; you can redistribute it and/or
modify it under the terms of the GNU Library General Public
License as published by the Free Software Foundation; either
version 2 of the License, or (at your option) any later version.
This library 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
Library General Public License for more details.
You should have received a copy of the GNU Library General Public License
along with this library; see the file COPYING.LIB. If not, write to
the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
Boston, MA 02110-1301, USA.
*/
//BEGIN INCLUDES
#include "katesyntaxmanager.h"
#include "katetextline.h"
#include "katedocument.h"
#include "katerenderer.h"
#include "kateglobal.h"
#include "kateschema.h"
#include "kateconfig.h"
#include "kateextendedattribute.h"
#include "katehighlight.h"
#include "katepartdebug.h"
#include "katedefaultcolors.h"
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
//END
using namespace KTextEditor;
//BEGIN KateHlManager
KateHlManager::KateHlManager()
: QObject()
, m_config(KTextEditor::EditorPrivate::unitTestMode() ? QString() :QStringLiteral("katesyntaxhighlightingrc")
, KTextEditor::EditorPrivate::unitTestMode() ? KConfig::SimpleConfig : KConfig::NoGlobals) // skip config for unit tests!
{
}
KateHlManager::~KateHlManager()
{
// delete the loaded highlightings, all other stuff is taken care of by the Repository
qDeleteAll(m_hlDict);
}
KateHlManager *KateHlManager::self()
{
return KTextEditor::EditorPrivate::self()->hlManager();
}
KateHighlighting *KateHlManager::getHl(int n)
{
// default to "None", must exist
if (n < 0 || n >= modeList().count()) {
n = nameFind(QStringLiteral("None"));
Q_ASSERT(n >= 0);
}
// construct it on demand
if (m_hlDict.contains(modeList().at(n).name())) {
return m_hlDict[modeList().at(n).name()];
}
return m_hlDict[modeList().at(n).name()] = new KateHighlighting(modeList().at(n));
}
int KateHlManager::nameFind(const QString &name)
{
for (int i = 0; i < modeList().count(); ++i) {
if (modeList().at(i).name().compare(name, Qt::CaseInsensitive) == 0) {
return i;
}
}
return -1;
}
int KateHlManager::defaultStyleCount()
{
return KTextEditor::dsError + 1;
}
QString KateHlManager::defaultStyleName(int n, bool translateNames)
{
static QStringList names;
static QStringList translatedNames;
if (names.isEmpty()) {
names << QStringLiteral("Normal");
names << QStringLiteral("Keyword");
names << QStringLiteral("Function");
names << QStringLiteral("Variable");
names << QStringLiteral("Control Flow");
names << QStringLiteral("Operator");
names << QStringLiteral("Built-in");
names << QStringLiteral("Extension");
names << QStringLiteral("Preprocessor");
names << QStringLiteral("Attribute");
names << QStringLiteral("Character");
names << QStringLiteral("Special Character");
names << QStringLiteral("String");
names << QStringLiteral("Verbatim String");
names << QStringLiteral("Special String");
names << QStringLiteral("Import");
names << QStringLiteral("Data Type");
names << QStringLiteral("Decimal/Value");
names << QStringLiteral("Base-N Integer");
names << QStringLiteral("Floating Point");
names << QStringLiteral("Constant");
names << QStringLiteral("Comment");
names << QStringLiteral("Documentation");
names << QStringLiteral("Annotation");
names << QStringLiteral("Comment Variable");
// this next one is for denoting the beginning/end of a user defined folding region
names << QStringLiteral("Region Marker");
names << QStringLiteral("Information");
names << QStringLiteral("Warning");
names << QStringLiteral("Alert");
names << QStringLiteral("Others");
// this one is for marking invalid input
names << QStringLiteral("Error");
translatedNames << i18nc("@item:intable Text context", "Normal");
translatedNames << i18nc("@item:intable Text context", "Keyword");
translatedNames << i18nc("@item:intable Text context", "Function");
translatedNames << i18nc("@item:intable Text context", "Variable");
translatedNames << i18nc("@item:intable Text context", "Control Flow");
translatedNames << i18nc("@item:intable Text context", "Operator");
translatedNames << i18nc("@item:intable Text context", "Built-in");
translatedNames << i18nc("@item:intable Text context", "Extension");
translatedNames << i18nc("@item:intable Text context", "Preprocessor");
translatedNames << i18nc("@item:intable Text context", "Attribute");
translatedNames << i18nc("@item:intable Text context", "Character");
translatedNames << i18nc("@item:intable Text context", "Special Character");
translatedNames << i18nc("@item:intable Text context", "String");
translatedNames << i18nc("@item:intable Text context", "Verbatim String");
translatedNames << i18nc("@item:intable Text context", "Special String");
translatedNames << i18nc("@item:intable Text context", "Imports, Modules, Includes");
translatedNames << i18nc("@item:intable Text context", "Data Type");
translatedNames << i18nc("@item:intable Text context", "Decimal/Value");
translatedNames << i18nc("@item:intable Text context", "Base-N Integer");
translatedNames << i18nc("@item:intable Text context", "Floating Point");
translatedNames << i18nc("@item:intable Text context", "Constant");
translatedNames << i18nc("@item:intable Text context", "Comment");
translatedNames << i18nc("@item:intable Text context", "Documentation");
translatedNames << i18nc("@item:intable Text context", "Annotation");
translatedNames << i18nc("@item:intable Text context", "Comment Variable");
// this next one is for denoting the beginning/end of a user defined folding region
translatedNames << i18nc("@item:intable Text context", "Region Marker");
translatedNames << i18nc("@item:intable Text context", "Information");
translatedNames << i18nc("@item:intable Text context", "Warning");
translatedNames << i18nc("@item:intable Text context", "Alert");
translatedNames << i18nc("@item:intable Text context", "Others");
// this one is for marking invalid input
translatedNames << i18nc("@item:intable Text context", "Error");
}
// sanity checks
Q_ASSERT(n >= 0);
Q_ASSERT(n < names.size());
return translateNames ? translatedNames[n] : names[n];
}
int KateHlManager::defaultStyleNameToIndex(const QString &name)
{
//
// Normal text and source code
//
if (name == QLatin1String("dsNormal")) {
return KTextEditor::dsNormal;
} else if (name == QLatin1String("dsKeyword")) {
return KTextEditor::dsKeyword;
} else if (name == QLatin1String("dsFunction")) {
return KTextEditor::dsFunction;
} else if (name == QLatin1String("dsVariable")) {
return KTextEditor::dsVariable;
} else if (name == QLatin1String("dsControlFlow")) {
return KTextEditor::dsControlFlow;
} else if (name == QLatin1String("dsOperator")) {
return KTextEditor::dsOperator;
} else if (name == QLatin1String("dsBuiltIn")) {
return KTextEditor::dsBuiltIn;
} else if (name == QLatin1String("dsExtension")) {
return KTextEditor::dsExtension;
} else if (name == QLatin1String("dsPreprocessor")) {
return KTextEditor::dsPreprocessor;
} else if (name == QLatin1String("dsAttribute")) {
return KTextEditor::dsAttribute;
}
//
// Strings & Characters
//
if (name == QLatin1String("dsChar")) {
return KTextEditor::dsChar;
} else if (name == QLatin1String("dsSpecialChar")) {
return KTextEditor::dsSpecialChar;
} else if (name == QLatin1String("dsString")) {
return KTextEditor::dsString;
} else if (name == QLatin1String("dsVerbatimString")) {
return KTextEditor::dsVerbatimString;
} else if (name == QLatin1String("dsSpecialString")) {
return KTextEditor::dsSpecialString;
} else if (name == QLatin1String("dsImport")) {
return KTextEditor::dsImport;
}
//
// Numbers, Types & Constants
//
if (name == QLatin1String("dsDataType")) {
return KTextEditor::dsDataType;
} else if (name == QLatin1String("dsDecVal")) {
return KTextEditor::dsDecVal;
} else if (name == QLatin1String("dsBaseN")) {
return KTextEditor::dsBaseN;
} else if (name == QLatin1String("dsFloat")) {
return KTextEditor::dsFloat;
} else if (name == QLatin1String("dsConstant")) {
return KTextEditor::dsConstant;
}
//
// Comments & Documentation
//
if (name == QLatin1String("dsComment")) {
return KTextEditor::dsComment;
} else if (name == QLatin1String("dsDocumentation")) {
return KTextEditor::dsDocumentation;
} else if (name == QLatin1String("dsAnnotation")) {
return KTextEditor::dsAnnotation;
} else if (name == QLatin1String("dsCommentVar")) {
return KTextEditor::dsCommentVar;
} else if (name == QLatin1String("dsRegionMarker")) {
return KTextEditor::dsRegionMarker;
} else if (name == QLatin1String("dsInformation")) {
return KTextEditor::dsInformation;
} else if (name == QLatin1String("dsWarning")) {
return KTextEditor::dsWarning;
} else if (name == QLatin1String("dsAlert")) {
return KTextEditor::dsAlert;
}
//
// Misc
//
if (name == QLatin1String("dsOthers")) {
return KTextEditor::dsOthers;
} else if (name == QLatin1String("dsError")) {
return KTextEditor::dsError;
}
return KTextEditor::dsNormal;
}
void KateHlManager::getDefaults(const QString &schema, KateAttributeList &list, KConfig *cfg)
{
const KColorScheme &scheme(KTextEditor::EditorPrivate::self()->defaultColors().view());
const KColorScheme &schemeSelected(KTextEditor::EditorPrivate::self()->defaultColors().selection());
///NOTE: it's important to append in the order of the KTextEditor::DefaultStyle
/// enum, to make KTextEditor::DocumentPrivate::defaultStyle() work properly.
{
// dsNormal
Attribute::Ptr attrib(new KTextEditor::Attribute());
attrib->setForeground(scheme.foreground().color());
attrib->setSelectedForeground(schemeSelected.foreground().color());
list.append(attrib);
}
{
// dsKeyword
Attribute::Ptr attrib(new KTextEditor::Attribute());
attrib->setForeground(scheme.foreground().color());
attrib->setSelectedForeground(schemeSelected.foreground().color());
attrib->setFontBold(true);
list.append(attrib);
}
{
// dsFunction
Attribute::Ptr attrib(new KTextEditor::Attribute());
attrib->setForeground(scheme.foreground(KColorScheme::NeutralText).color());
attrib->setSelectedForeground(schemeSelected.foreground(KColorScheme::NeutralText).color());
list.append(attrib);
}
{
// dsVariable
Attribute::Ptr attrib(new KTextEditor::Attribute());
attrib->setForeground(scheme.foreground(KColorScheme::LinkText).color());
attrib->setSelectedForeground(schemeSelected.foreground(KColorScheme::LinkText).color());
list.append(attrib);
}
{
// dsControlFlow
Attribute::Ptr attrib(new KTextEditor::Attribute());
attrib->setForeground(scheme.foreground().color());
attrib->setSelectedForeground(schemeSelected.foreground().color());
attrib->setFontBold(true);
list.append(attrib);
}
{
// dsOperator
Attribute::Ptr attrib(new KTextEditor::Attribute());
attrib->setForeground(scheme.foreground().color());
attrib->setSelectedForeground(schemeSelected.foreground().color());
list.append(attrib);
}
{
// dsBuiltIn
Attribute::Ptr attrib(new KTextEditor::Attribute());
attrib->setForeground(scheme.foreground(KColorScheme::VisitedText).color());
attrib->setSelectedForeground(schemeSelected.foreground(KColorScheme::VisitedText).color());
list.append(attrib);
}
{
// dsExtension
Attribute::Ptr attrib(new KTextEditor::Attribute());
attrib->setForeground(QColor(0, 149, 255));
attrib->setSelectedForeground(schemeSelected.foreground().color());
attrib->setFontBold(true);
list.append(attrib);
}
{
// dsPreprocessor
Attribute::Ptr attrib(new KTextEditor::Attribute());
attrib->setForeground(scheme.foreground(KColorScheme::PositiveText).color());
attrib->setSelectedForeground(schemeSelected.foreground(KColorScheme::PositiveText).color());
list.append(attrib);
}
{
// dsAttribute
Attribute::Ptr attrib(new KTextEditor::Attribute());
attrib->setForeground(scheme.foreground(KColorScheme::LinkText).color());
attrib->setSelectedForeground(schemeSelected.foreground(KColorScheme::LinkText).color());
list.append(attrib);
}
{
// dsChar
Attribute::Ptr attrib(new KTextEditor::Attribute());
attrib->setForeground(scheme.foreground(KColorScheme::ActiveText).color());
attrib->setSelectedForeground(schemeSelected.foreground(KColorScheme::ActiveText).color());
list.append(attrib);
}
{
// dsSpecialChar
Attribute::Ptr attrib(new KTextEditor::Attribute());
attrib->setForeground(scheme.foreground(KColorScheme::ActiveText).color());
attrib->setSelectedForeground(schemeSelected.foreground(KColorScheme::ActiveText).color());
list.append(attrib);
}
{
// dsString
Attribute::Ptr attrib(new KTextEditor::Attribute());
attrib->setForeground(scheme.foreground(KColorScheme::NegativeText).color());
attrib->setSelectedForeground(schemeSelected.foreground(KColorScheme::NegativeText).color());
list.append(attrib);
}
{
// dsVerbatimString
Attribute::Ptr attrib(new KTextEditor::Attribute());
attrib->setForeground(scheme.foreground(KColorScheme::NegativeText).color());
attrib->setSelectedForeground(schemeSelected.foreground(KColorScheme::NegativeText).color());
list.append(attrib);
}
{
// dsSpecialString
Attribute::Ptr attrib(new KTextEditor::Attribute());
attrib->setForeground(scheme.foreground(KColorScheme::NegativeText).color());
attrib->setSelectedForeground(schemeSelected.foreground(KColorScheme::NegativeText).color());
list.append(attrib);
}
{
// dsImport
Attribute::Ptr attrib(new KTextEditor::Attribute());
attrib->setForeground(scheme.foreground(KColorScheme::VisitedText).color());
attrib->setSelectedForeground(schemeSelected.foreground(KColorScheme::VisitedText).color());
list.append(attrib);
}
{
// dsDataType
Attribute::Ptr attrib(new KTextEditor::Attribute());
attrib->setForeground(scheme.foreground(KColorScheme::LinkText).color());
attrib->setSelectedForeground(schemeSelected.foreground(KColorScheme::LinkText).color());
list.append(attrib);
}
{
// dsDecVal
Attribute::Ptr attrib(new KTextEditor::Attribute());
attrib->setForeground(scheme.foreground(KColorScheme::NeutralText).color());
attrib->setSelectedForeground(schemeSelected.foreground(KColorScheme::NeutralText).color());
list.append(attrib);
}
{
// dsBaseN
Attribute::Ptr attrib(new KTextEditor::Attribute());
attrib->setForeground(scheme.foreground(KColorScheme::NeutralText).color());
attrib->setSelectedForeground(schemeSelected.foreground(KColorScheme::NeutralText).color());
list.append(attrib);
}
{
// dsFloat
Attribute::Ptr attrib(new KTextEditor::Attribute());
attrib->setForeground(scheme.foreground(KColorScheme::NeutralText).color());
attrib->setSelectedForeground(schemeSelected.foreground(KColorScheme::NeutralText).color());
list.append(attrib);
}
{
// dsConstant
Attribute::Ptr attrib(new KTextEditor::Attribute());
attrib->setForeground(scheme.foreground().color());
attrib->setSelectedForeground(schemeSelected.foreground().color());
attrib->setFontBold(true);
list.append(attrib);
}
{
// dsComment
Attribute::Ptr attrib(new KTextEditor::Attribute());
attrib->setForeground(scheme.foreground(KColorScheme::InactiveText).color());
attrib->setSelectedForeground(schemeSelected.foreground(KColorScheme::InactiveText).color());
list.append(attrib);
}
{
// dsDocumentation
Attribute::Ptr attrib(new KTextEditor::Attribute());
attrib->setForeground(scheme.foreground(KColorScheme::NegativeText).color());
attrib->setSelectedForeground(schemeSelected.foreground(KColorScheme::NegativeText).color());
list.append(attrib);
}
{
// dsAnnotation
Attribute::Ptr attrib(new KTextEditor::Attribute());
attrib->setForeground(scheme.foreground(KColorScheme::VisitedText).color());
attrib->setSelectedForeground(schemeSelected.foreground(KColorScheme::VisitedText).color());
list.append(attrib);
}
{
// dsCommentVar
Attribute::Ptr attrib(new KTextEditor::Attribute());
attrib->setForeground(scheme.foreground(KColorScheme::VisitedText).color());
attrib->setSelectedForeground(schemeSelected.foreground(KColorScheme::VisitedText).color());
list.append(attrib);
}
{
// dsRegionMarker
Attribute::Ptr attrib(new KTextEditor::Attribute());
attrib->setForeground(scheme.foreground(KColorScheme::LinkText).color());
attrib->setSelectedForeground(schemeSelected.foreground(KColorScheme::LinkText).color());
attrib->setBackground(scheme.background(KColorScheme::LinkBackground).color());
list.append(attrib);
}
{
// dsInformation
Attribute::Ptr attrib(new KTextEditor::Attribute());
attrib->setForeground(scheme.foreground(KColorScheme::NeutralText).color());
attrib->setSelectedForeground(schemeSelected.foreground(KColorScheme::NeutralText).color());
list.append(attrib);
}
{
// dsWarning
Attribute::Ptr attrib(new KTextEditor::Attribute());
attrib->setForeground(scheme.foreground(KColorScheme::NegativeText).color());
attrib->setSelectedForeground(schemeSelected.foreground(KColorScheme::NegativeText).color());
list.append(attrib);
}
{
// dsAlert
Attribute::Ptr attrib(new KTextEditor::Attribute());
attrib->setForeground(scheme.foreground(KColorScheme::NegativeText).color());
attrib->setSelectedForeground(schemeSelected.foreground(KColorScheme::NegativeText).color());
attrib->setFontBold(true);
attrib->setBackground(scheme.background(KColorScheme::NegativeBackground).color());
list.append(attrib);
}
{
// dsOthers
Attribute::Ptr attrib(new KTextEditor::Attribute());
attrib->setForeground(scheme.foreground(KColorScheme::PositiveText).color());
attrib->setSelectedForeground(schemeSelected.foreground(KColorScheme::PositiveText).color());
list.append(attrib);
}
{
// dsError
Attribute::Ptr attrib(new KTextEditor::Attribute());
attrib->setForeground(scheme.foreground(KColorScheme::NegativeText));
attrib->setSelectedForeground(schemeSelected.foreground(KColorScheme::NegativeText).color());
attrib->setFontUnderline(true);
list.append(attrib);
}
KConfigGroup config(cfg ? cfg : KateHlManager::self()->self()->getKConfig(),
QLatin1String("Default Item Styles - Schema ") + schema);
for (int z = 0; z < defaultStyleCount(); z++) {
KTextEditor::Attribute::Ptr i = list.at(z);
QStringList s = config.readEntry(defaultStyleName(z), QStringList());
if (!s.isEmpty()) {
while (s.count() < 9) {
s << QString();
}
QString tmp;
QRgb col;
tmp = s[0]; if (!tmp.isEmpty()) {
col = tmp.toUInt(nullptr, 16); i->setForeground(QColor(col));
}
tmp = s[1]; if (!tmp.isEmpty()) {
col = tmp.toUInt(nullptr, 16); i->setSelectedForeground(QColor(col));
}
tmp = s[2]; if (!tmp.isEmpty()) {
i->setFontBold(tmp != QLatin1String("0"));
}
tmp = s[3]; if (!tmp.isEmpty()) {
i->setFontItalic(tmp != QLatin1String("0"));
}
tmp = s[4]; if (!tmp.isEmpty()) {
i->setFontStrikeOut(tmp != QLatin1String("0"));
}
tmp = s[5]; if (!tmp.isEmpty()) {
i->setFontUnderline(tmp != QLatin1String("0"));
}
tmp = s[6]; if (!tmp.isEmpty()) {
if (tmp != QLatin1String("-")) {
col = tmp.toUInt(nullptr, 16);
i->setBackground(QColor(col));
} else {
i->clearBackground();
}
}
tmp = s[7]; if (!tmp.isEmpty()) {
if (tmp != QLatin1String("-")) {
col = tmp.toUInt(nullptr, 16);
i->setSelectedBackground(QColor(col));
} else {
i->clearProperty(SelectedBackground);
}
}
tmp = s[8]; if (!tmp.isEmpty() && tmp != QLatin1String("---")) {
i->setFontFamily(tmp);
}
}
}
}
void KateHlManager::setDefaults(const QString &schema, KateAttributeList &list, KConfig *cfg)
{
cfg = cfg ? cfg : KateHlManager::self()->self()->getKConfig();
KConfigGroup config(cfg,
QLatin1String("Default Item Styles - Schema ") + schema);
const QString zero = QStringLiteral("0");
const QString one = QStringLiteral("1");
const QString dash = QStringLiteral("-");
for (int z = 0; z < defaultStyleCount(); z++) {
QStringList settings;
KTextEditor::Attribute::Ptr p = list.at(z);
settings << (p->hasProperty(QTextFormat::ForegroundBrush) ? QString::number(p->foreground().color().rgb(), 16) : QString());
settings << (p->hasProperty(SelectedForeground) ? QString::number(p->selectedForeground().color().rgb(), 16) : QString());
settings << (p->hasProperty(QTextFormat::FontWeight) ? (p->fontBold() ? one : zero) : QString());
settings << (p->hasProperty(QTextFormat::FontItalic) ? (p->fontItalic() ? one : zero) : QString());
settings << (p->hasProperty(QTextFormat::FontStrikeOut) ? (p->fontStrikeOut() ? one : zero) : QString());
settings << (p->hasProperty(QTextFormat::FontUnderline) ? (p->fontUnderline() ? one : zero) : QString());
settings << (p->hasProperty(QTextFormat::BackgroundBrush) ? QString::number(p->background().color().rgb(), 16) : dash);
settings << (p->hasProperty(SelectedBackground) ? QString::number(p->selectedBackground().color().rgb(), 16) : dash);
settings << (p->hasProperty(QTextFormat::FontFamily) ? (p->fontFamily()) : QString());
settings << QStringLiteral("---");
config.writeEntry(defaultStyleName(z), settings);
}
emit changed();
}
-int KateHlManager::highlights()
-{
- return modeList().count();
-}
-
-QString KateHlManager::hlName(int n)
-{
- return modeList().at(n).name();
-}
-
-QString KateHlManager::hlNameTranslated(int n)
-{
- return modeList().at(n).translatedName();
-}
-
-QString KateHlManager::hlSection(int n)
-{
- return modeList().at(n).section();
-}
-
-bool KateHlManager::hlHidden(int n)
-{
- return modeList().at(n).isHidden();
-}
-
void KateHlManager::reload()
{
/**
* move current loaded hls from hash to trigger recreation
*/
auto oldHls = m_hlDict;
m_hlDict.clear();
/**
* recreate repository
* this might even remove highlighting modes known before
*/
m_repository.reload();
/**
* let all documents use the new highlighters
* will be created on demand
* if old hl not found, use none
*/
for (KTextEditor::DocumentPrivate* doc : KTextEditor::EditorPrivate::self()->kateDocuments()) {
auto hlMode = doc->highlightingMode();
if (nameFind(hlMode) < 0) {
hlMode = QStringLiteral("None");
}
doc->setHighlightingMode(hlMode);
}
/**
* delete old highlightings, now no longer referenced
*/
qDeleteAll(oldHls);
}
//END
diff --git a/src/syntax/katesyntaxmanager.h b/src/syntax/katesyntaxmanager.h
index 285378ac..e81c31cb 100644
--- a/src/syntax/katesyntaxmanager.h
+++ b/src/syntax/katesyntaxmanager.h
@@ -1,134 +1,128 @@
/* This file is part of the KDE libraries
Copyright (C) 2001,2002 Joseph Wenninger
Copyright (C) 2001 Christoph Cullmann
Copyright (C) 1999 Jochen Wilhelmy
This library is free software; you can redistribute it and/or
modify it under the terms of the GNU Library General Public
License as published by the Free Software Foundation; either
version 2 of the License, or (at your option) any later version.
This library 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
Library General Public License for more details.
You should have received a copy of the GNU Library General Public License
along with this library; see the file COPYING.LIB. If not, write to
the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
Boston, MA 02110-1301, USA.
*/
#ifndef __KATE_SYNTAXMANAGER_H__
#define __KATE_SYNTAXMANAGER_H__
#include "katetextline.h"
#include "kateextendedattribute.h"
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
class KateHighlighting;
class KateHlManager : public QObject
{
Q_OBJECT
public:
KateHlManager();
~KateHlManager();
static KateHlManager *self();
inline KConfig *getKConfig()
{
return &m_config;
}
KateHighlighting *getHl(int n);
int nameFind(const QString &name);
void getDefaults(const QString &schema, KateAttributeList &, KConfig *cfg = nullptr);
void setDefaults(const QString &schema, KateAttributeList &, KConfig *cfg = nullptr);
- int highlights();
- QString hlName(int n);
- QString hlNameTranslated(int n);
- QString hlSection(int n);
- bool hlHidden(int n);
-
void reload();
Q_SIGNALS:
void changed();
//
// methodes to get the default style count + names
//
public:
/**
* Return the number of default styles.
*/
static int defaultStyleCount();
/**
* Return the name of default style @p n. If @p translateNames is @e true,
* the default style name is translated.
*/
static QString defaultStyleName(int n, bool translateNames = false);
/**
* Return the index for the default style @p name.
* @param name @e untranslated default style
* @see KTextEditor::DefaultStyles)
*/
static int defaultStyleNameToIndex(const QString &name);
/**
* Get the mode list
* @return mode list
*/
QVector modeList() const
{
return m_repository.definitions();
}
/**
* Get repository.
* @return repository
*/
KSyntaxHighlighting::Repository &repository()
{
return m_repository;
}
private:
friend class KateHighlighting;
/**
* Syntax highlighting definitions.
*/
KSyntaxHighlighting::Repository m_repository;
/**
* All loaded highlightings.
*/
QHash m_hlDict;
KConfig m_config;
};
#endif
diff --git a/src/utils/katecmds.cpp b/src/utils/katecmds.cpp
index f671eea2..990f3260 100644
--- a/src/utils/katecmds.cpp
+++ b/src/utils/katecmds.cpp
@@ -1,597 +1,597 @@
/* This file is part of the KDE libraries and the Kate part.
*
* Copyright (C) 2003-2005 Anders Lund
* Copyright (C) 2001-2010 Christoph Cullmann
* Copyright (C) 2001 Charles Samuels
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Library General Public
* License as published by the Free Software Foundation; either
* version 2 of the License, or (at your option) any later version.
*
* This library 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
* Library General Public License for more details.
*
* You should have received a copy of the GNU Library General Public License
* along with this library; see the file COPYING.LIB. If not, write to
* the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
* Boston, MA 02110-1301, USA.
*/
#include "katecmds.h"
#include "katedocument.h"
#include "kateview.h"
#include "kateautoindent.h"
#include "katetextline.h"
#include "katesyntaxmanager.h"
#include "katerenderer.h"
#include "katecmd.h"
#include "katepartdebug.h"
#include
#include
//BEGIN CoreCommands
KateCommands::CoreCommands *KateCommands::CoreCommands::m_instance = nullptr;
// this returns wheather the string s could be converted to
// a bool value, one of on|off|1|0|true|false. the argument val is
// set to the extracted value in case of success
static bool getBoolArg(const QString &t, bool *val)
{
bool res(false);
QString s = t.toLower();
res = (s == QLatin1String("on") || s == QLatin1String("1") || s == QLatin1String("true"));
if (res) {
*val = true;
return true;
}
res = (s == QLatin1String("off") || s == QLatin1String("0") || s == QLatin1String("false"));
if (res) {
*val = false;
return true;
}
return false;
}
bool KateCommands::CoreCommands::help(KTextEditor::View *, const QString &cmd, QString &msg)
{
QString realcmd = cmd.trimmed();
if (realcmd == QLatin1String("indent")) {
msg = i18n("indent
"
"Indents the selected lines or the current line
");
return true;
} else if (realcmd == QLatin1String("unindent")) {
msg = i18n("unindent
"
"Unindents the selected lines or current line.
");
return true;
} else if (realcmd == QLatin1String("cleanindent")) {
msg = i18n("cleanindent
"
"Cleans up the indentation of the selected lines or current line according to the indentation settings in the document.
");
return true;
} else if (realcmd == QLatin1String("comment")) {
msg = i18n("comment
"
"Inserts comment markers to make the selection or selected lines or current line a comment according to the text format as defined by the syntax highlight definition for the document.
");
return true;
} else if (realcmd == QLatin1String("uncomment")) {
msg = i18n("uncomment
"
"Removes comment markers from the selection or selected lines or current line according to the text format as defined by the syntax highlight definition for the document.
");
return true;
} else if (realcmd == QLatin1String("goto")) {
msg = i18n("goto line number
"
"This command navigates to the specified line number.
");
return true;
} else if (realcmd == QLatin1String("set-indent-pasted-text")) {
msg = i18n("set-indent-pasted-text enable
"
"If enabled, indentation of text pasted from the clipboard is adjusted using the current indenter.
"
"Possible true values: 1 on true
"
"possible false values: 0 off false
");
return true;
} else if (realcmd == QLatin1String("kill-line")) {
msg = i18n("Deletes the current line.");
return true;
} else if (realcmd == QLatin1String("set-tab-width")) {
msg = i18n("set-tab-width width
"
"Sets the tab width to the number width
");
return true;
} else if (realcmd == QLatin1String("set-replace-tab")) {
msg = i18n("set-replace-tab enable
"
"If enabled, tabs are replaced with spaces as you type.
"
"Possible true values: 1 on true
"
"possible false values: 0 off false
");
return true;
} else if (realcmd == QLatin1String("set-show-tabs")) {
msg = i18n("set-show-tabs enable
"
"If enabled, TAB characters and trailing whitespace will be visualized by a small dot.
"
"Possible true values: 1 on true
"
"possible false values: 0 off false
");
return true;
} else if (realcmd == QLatin1String("set-remove-trailing-spaces")) {
msg = i18n("set-remove-trailing-spaces mode
"
"Removes the trailing spaces in the document depending on the mode.
"
"Possible values:"
"
"
"- none: never remove trailing spaces.
"
"- modified: remove trailing spaces only of modified lines.
"
"- all: remove trailing spaces in the entire document.
"
"
");
return true;
} else if (realcmd == QLatin1String("set-indent-width")) {
msg = i18n("set-indent-width width
"
"Sets the indentation width to the number width. Used only if you are indenting with spaces.
");
return true;
} else if (realcmd == QLatin1String("set-indent-mode")) {
msg = i18n("set-indent-mode mode
"
"The mode parameter is a value as seen in the Tools - Indentation menu
");
return true;
} else if (realcmd == QLatin1String("set-auto-indent")) {
msg = i18n("set-auto-indent enable
"
"Enable or disable autoindentation.
"
"possible true values: 1 on true
"
"possible false values: 0 off false
");
return true;
} else if (realcmd == QLatin1String("set-line-numbers")) {
msg = i18n("set-line-numbers enable
"
"Sets the visibility of the line numbers pane.
"
" possible true values: 1 on true
"
"possible false values: 0 off false
");
return true;
} else if (realcmd == QLatin1String("set-folding-markers")) {
msg = i18n("set-folding-markers enable
"
"Sets the visibility of the folding markers pane.
"
" possible true values: 1 on true
"
"possible false values: 0 off false
");
return true;
} else if (realcmd == QLatin1String("set-icon-border")) {
msg = i18n("set-icon-border enable
"
"Sets the visibility of the icon border.
"
" possible true values: 1 on true
"
"possible false values: 0 off false
");
return true;
} else if (realcmd == QLatin1String("set-word-wrap")) {
msg = i18n("set-word-wrap enable
"
"Enables dynamic word wrap according to enable
"
" possible true values: 1 on true
"
"possible false values: 0 off false
");
return true;
} else if (realcmd == QLatin1String("set-word-wrap-column")) {
msg = i18n("set-word-wrap-column width
"
"Sets the line width for hard wrapping to width. This is used if you are having your text wrapped automatically.
");
return true;
} else if (realcmd == QLatin1String("set-replace-tabs-save")) {
msg = i18n("set-replace-tabs-save enable
"
"When enabled, tabs will be replaced with whitespace whenever the document is saved.
"
" possible true values: 1 on true
"
"possible false values: 0 off false
");
return true;
} else if (realcmd == QLatin1String("set-highlight")) {
msg = i18n("set-highlight highlight
"
"Sets the syntax highlighting system for the document. The argument must be a valid highlight name, as seen in the Tools → Highlighting menu. This command provides an autocompletion list for its argument.
");
return true;
} else if (realcmd == QLatin1String("set-mode")) {
msg = i18n("set-mode mode
"
"Sets the mode as seen in Tools - Mode
");
return true;
} else if (realcmd == QLatin1String("set-show-indent")) {
msg = i18n("set-show-indent enable
"
"If enabled, indentation will be visualized by a vertical dotted line.
"
" possible true values: 1 on true
"
"possible false values: 0 off false
");
return true;
} else if (realcmd == QLatin1String("print")) {
msg = i18n("Open the Print dialog to print the current document.
");
return true;
} else {
return false;
}
}
bool KateCommands::CoreCommands::exec(KTextEditor::View *view,
const QString &_cmd,
QString &errorMsg,
const KTextEditor::Range &range)
{
#define KCC_ERR(s) { errorMsg=s; return false; }
// cast it hardcore, we know that it is really a kateview :)
KTextEditor::ViewPrivate *v = static_cast(view);
if (! v) {
KCC_ERR(i18n("Could not access view"));
}
//create a list of args
QStringList args(_cmd.split(QRegularExpression(QLatin1String("\\s+")), QString::SkipEmptyParts));
QString cmd(args.takeFirst());
// ALL commands that takes no arguments.
if (cmd == QLatin1String("indent")) {
if (range.isValid()) {
v->doc()->editStart();
for (int line = range.start().line(); line <= range.end().line(); line++) {
v->doc()->indent(KTextEditor::Range(line, 0, line, 0), 1);
}
v->doc()->editEnd();
} else {
v->indent();
}
return true;
} else if (cmd == QLatin1String("unindent")) {
if (range.isValid()) {
v->doc()->editStart();
for (int line = range.start().line(); line <= range.end().line(); line++) {
v->doc()->indent(KTextEditor::Range(line, 0, line, 0), -1);
}
v->doc()->editEnd();
} else {
v->unIndent();
}
return true;
} else if (cmd == QLatin1String("cleanindent")) {
if (range.isValid()) {
v->doc()->editStart();
for (int line = range.start().line(); line <= range.end().line(); line++) {
v->doc()->indent(KTextEditor::Range(line, 0, line, 0), 0);
}
v->doc()->editEnd();
} else {
v->cleanIndent();
}
return true;
} else if (cmd == QLatin1String("fold")) {
return (v->textFolding().newFoldingRange(range.isValid() ? range : v->selectionRange(), Kate::TextFolding::Persistent | Kate::TextFolding::Folded) != -1);
} else if (cmd == QLatin1String("tfold")) {
return (v->textFolding().newFoldingRange(range.isValid() ? range : v->selectionRange(), Kate::TextFolding::Folded) != -1);
} else if (cmd == QLatin1String("unfold")) {
QVector > startingRanges = v->textFolding().foldingRangesStartingOnLine(v->cursorPosition().line());
bool unfolded = false;
for (int i = 0; i < startingRanges.size(); ++i) {
if (startingRanges[i].second & Kate::TextFolding::Folded) {
unfolded = v->textFolding().unfoldRange(startingRanges[i].first) || unfolded;
}
}
return unfolded;
} else if (cmd == QLatin1String("comment")) {
if (range.isValid()) {
v->doc()->editStart();
for (int line = range.start().line(); line <= range.end().line(); line++) {
v->doc()->comment(v, line, 0, 1);
}
v->doc()->editEnd();
} else {
v->comment();
}
return true;
} else if (cmd == QLatin1String("uncomment")) {
if (range.isValid()) {
v->doc()->editStart();
for (int line = range.start().line(); line <= range.end().line(); line++) {
v->doc()->comment(v, line, 0, -1);
}
v->doc()->editEnd();
} else {
v->uncomment();
}
return true;
} else if (cmd == QLatin1String("kill-line")) {
if (range.isValid()) {
v->doc()->editStart();
for (int line = range.start().line(); line <= range.end().line(); line++) {
v->doc()->removeLine(range.start().line());
}
v->doc()->editEnd();
} else {
v->killLine();
}
return true;
} else if (cmd == QLatin1String("print")) {
v->print();
return true;
}
// ALL commands that take a string argument
else if (cmd == QLatin1String("set-indent-mode") ||
cmd == QLatin1String("set-highlight") ||
cmd == QLatin1String("set-mode")) {
// need at least one item, otherwise args.first() crashes
if (args.isEmpty()) {
KCC_ERR(i18n("Missing argument. Usage: %1 ", cmd));
}
if (cmd == QLatin1String("set-indent-mode")) {
v->doc()->config()->setIndentationMode(args.join(QLatin1Char(' ')));
v->doc()->rememberUserDidSetIndentationMode();
return true;
} else if (cmd == QLatin1String("set-highlight")) {
if (v->doc()->setHighlightingMode(args.join(QLatin1Char(' ')))) {
static_cast(v->doc())->setDontChangeHlOnSave();
return true;
}
KCC_ERR(i18n("No such highlighting '%1'", args.first()));
} else if (cmd == QLatin1String("set-mode")) {
if (v->doc()->setMode(args.first())) {
return true;
}
KCC_ERR(i18n("No such mode '%1'", args.first()));
}
}
// ALL commands that takes exactly one integer argument.
else if (cmd == QLatin1String("set-tab-width") ||
cmd == QLatin1String("set-indent-width") ||
cmd == QLatin1String("set-word-wrap-column") ||
cmd == QLatin1String("goto")) {
// find a integer value > 0
if (args.isEmpty()) {
KCC_ERR(i18n("Missing argument. Usage: %1 ", cmd));
}
bool ok;
int val(args.first().toInt(&ok, 10)); // use base 10 even if the string starts with '0'
if (!ok)
KCC_ERR(i18n("Failed to convert argument '%1' to integer.",
args.first()));
if (cmd == QLatin1String("set-tab-width")) {
if (val < 1) {
KCC_ERR(i18n("Width must be at least 1."));
}
v->doc()->config()->setTabWidth(val);
} else if (cmd == QLatin1String("set-indent-width")) {
if (val < 1) {
KCC_ERR(i18n("Width must be at least 1."));
}
v->doc()->config()->setIndentationWidth(val);
} else if (cmd == QLatin1String("set-word-wrap-column")) {
if (val < 2) {
KCC_ERR(i18n("Column must be at least 1."));
}
v->doc()->setWordWrapAt(val);
} else if (cmd == QLatin1String("goto")) {
if (args.first().at(0) == QLatin1Char('-') || args.first().at(0) == QLatin1Char('+')) {
// if the number starts with a minus or plus sign, add/subract the number
val = v->cursorPosition().line() + val;
} else {
val--; // convert given line number to the internal representation of line numbers
}
// constrain cursor to the range [0, number of lines]
if (val < 0) {
val = 0;
} else if (val > v->doc()->lines() - 1) {
val = v->doc()->lines() - 1;
}
v->setCursorPosition(KTextEditor::Cursor(val, 0));
return true;
}
return true;
}
// ALL commands that takes 1 boolean argument.
else if (cmd == QLatin1String("set-icon-border") ||
cmd == QLatin1String("set-folding-markers") ||
cmd == QLatin1String("set-indent-pasted-text") ||
cmd == QLatin1String("set-line-numbers") ||
cmd == QLatin1String("set-replace-tabs") ||
cmd == QLatin1String("set-show-tabs") ||
cmd == QLatin1String("set-word-wrap") ||
cmd == QLatin1String("set-wrap-cursor") ||
cmd == QLatin1String("set-replace-tabs-save") ||
cmd == QLatin1String("set-show-indent")) {
if (args.isEmpty()) {
KCC_ERR(i18n("Usage: %1 on|off|1|0|true|false", cmd));
}
bool enable = false;
KateDocumentConfig *const config = v->doc()->config();
if (getBoolArg(args.first(), &enable)) {
if (cmd == QLatin1String("set-icon-border")) {
v->setIconBorder(enable);
} else if (cmd == QLatin1String("set-folding-markers")) {
v->setFoldingMarkersOn(enable);
} else if (cmd == QLatin1String("set-line-numbers")) {
v->setLineNumbersOn(enable);
} else if (cmd == QLatin1String("set-show-indent")) {
v->renderer()->setShowIndentLines(enable);
} else if (cmd == QLatin1String("set-indent-pasted-text")) {
config->setIndentPastedText(enable);
} else if (cmd == QLatin1String("set-replace-tabs")) {
config->setReplaceTabsDyn(enable);
} else if (cmd == QLatin1String("set-show-tabs")) {
config->setShowTabs(enable);
} else if (cmd == QLatin1String("set-show-trailing-spaces")) {
config->setShowSpaces(enable);
} else if (cmd == QLatin1String("set-word-wrap")) {
v->doc()->setWordWrap(enable);
}
return true;
} else
KCC_ERR(i18n("Bad argument '%1'. Usage: %2 on|off|1|0|true|false",
args.first(), cmd));
} else if (cmd == QLatin1String("set-remove-trailing-spaces")) {
// need at least one item, otherwise args.first() crashes
if (args.count() != 1) {
KCC_ERR(i18n("Usage: set-remove-trailing-spaces 0|-|none or 1|+|mod|modified or 2|*|all"));
}
QString tmp = args.first().toLower().trimmed();
if (tmp == QLatin1String("1") || tmp == QLatin1String("modified") || tmp == QLatin1String("mod") || tmp == QLatin1String("+")) {
v->doc()->config()->setRemoveSpaces(1);
} else if (tmp == QLatin1String("2") || tmp == QLatin1String("all") || tmp == QLatin1String("*")) {
v->doc()->config()->setRemoveSpaces(2);
} else {
v->doc()->config()->setRemoveSpaces(0);
}
}
// unlikely..
KCC_ERR(i18n("Unknown command '%1'", cmd));
}
bool KateCommands::CoreCommands::supportsRange(const QString &range)
{
static QStringList l;
if (l.isEmpty())
l << QStringLiteral("indent") << QStringLiteral("unindent") << QStringLiteral("cleanindent")
<< QStringLiteral("comment") << QStringLiteral("uncomment") << QStringLiteral("kill-line") << QStringLiteral("fold") << QStringLiteral("tfold");
return l.contains(range);
}
KCompletion *KateCommands::CoreCommands::completionObject(KTextEditor::View *view, const QString &cmd)
{
Q_UNUSED(view)
if (cmd == QLatin1String("set-highlight")) {
QStringList l;
- for (int i = 0; i < KateHlManager::self()->highlights(); i++) {
- l << KateHlManager::self()->hlName(i);
+ for (const auto &hl : KateHlManager::self()->modeList()) {
+ l << hl.name();
}
KateCmdShellCompletion *co = new KateCmdShellCompletion();
co->setItems(l);
co->setIgnoreCase(true);
return co;
} else if (cmd == QLatin1String("set-remove-trailing-spaces")) {
QStringList l;
l << QStringLiteral("none") << QStringLiteral("modified") << QStringLiteral("all");
KateCmdShellCompletion *co = new KateCmdShellCompletion();
co->setItems(l);
co->setIgnoreCase(true);
return co;
} else if (cmd == QLatin1String("set-indent-mode")) {
QStringList l = KateAutoIndent::listIdentifiers();
KateCmdShellCompletion *co = new KateCmdShellCompletion();
co->setItems(l);
co->setIgnoreCase(true);
return co;
}
return nullptr;
}
//END CoreCommands
//BEGIN Character
KateCommands::Character *KateCommands::Character::m_instance = nullptr;
bool KateCommands::Character::help(class KTextEditor::View *, const QString &cmd, QString &msg)
{
if (cmd.trimmed() == QLatin1String("char")) {
msg = i18n(" char identifier
"
"This command allows you to insert literal characters by their numerical identifier, in decimal, octal or hexadecimal form.
"
"Examples:
"
"- char 234
"
"- char 0x1234
"
"
");
return true;
}
return false;
}
bool KateCommands::Character::exec(KTextEditor::View *view, const QString &_cmd, QString &, const KTextEditor::Range &)
{
QString cmd = _cmd;
// hex, octal, base 9+1
QRegularExpression num(QLatin1String("^char *(0?x[0-9A-Fa-f]{1,4}|0[0-7]{1,6}|[0-9]{1,5})$"));
QRegularExpressionMatch match = num.match(cmd);
if (!match.hasMatch()) {
return false;
}
cmd = match.captured(1);
// identify the base
unsigned short int number = 0;
int base = 10;
if (cmd.startsWith(QLatin1Char('x'))) {
cmd.remove(0, 1);
base = 16;
} else if (cmd.startsWith(QStringLiteral("0x"))) {
cmd.remove(0, 2);
base = 16;
} else if (cmd[0] == QLatin1Char('0')) {
base = 8;
}
bool ok;
number = cmd.toUShort(&ok, base);
if (!ok || number == 0) {
return false;
}
if (number <= 255) {
char buf[2];
buf[0] = (char)number;
buf[1] = 0;
view->document()->insertText(view->cursorPosition(), QString::fromLatin1(buf));
} else {
// do the unicode thing
QChar c(number);
view->document()->insertText(view->cursorPosition(), QString(&c, 1));
}
return true;
}
//END Character
//BEGIN Date
KateCommands::Date *KateCommands::Date::m_instance = nullptr;
bool KateCommands::Date::help(class KTextEditor::View *, const QString &cmd, QString &msg)
{
if (cmd.trimmed() == QLatin1String("date")) {
msg = i18n("date or date format
"
"Inserts a date/time string as defined by the specified format, or the format yyyy-MM-dd hh:mm:ss if none is specified.
"
"Possible format specifiers are:"
"
"
"d | The day as number without a leading zero (1-31). |
"
"dd | The day as number with a leading zero (01-31). |
"
"ddd | The abbreviated localized day name (e.g. 'Mon'..'Sun'). |
"
"dddd | The long localized day name (e.g. 'Monday'..'Sunday'). |
"
"M | The month as number without a leading zero (1-12). |
"
"MM | The month as number with a leading zero (01-12). |
"
"MMM | The abbreviated localized month name (e.g. 'Jan'..'Dec'). |
"
"yy | The year as two digit number (00-99). |
"
"yyyy | The year as four digit number (1752-8000). |
"
"h | The hour without a leading zero (0..23 or 1..12 if AM/PM display). |
"
"hh | The hour with a leading zero (00..23 or 01..12 if AM/PM display). |
"
"m | The minute without a leading zero (0..59). |
"
"mm | The minute with a leading zero (00..59). |
"
"s | The second without a leading zero (0..59). |
"
"ss | The second with a leading zero (00..59). |
"
"z | The milliseconds without leading zeroes (0..999). |
"
"zzz | The milliseconds with leading zeroes (000..999). |
"
"AP | Use AM/PM display. AP will be replaced by either \"AM\" or \"PM\". |
"
"ap | Use am/pm display. ap will be replaced by either \"am\" or \"pm\". |
"
"
");
return true;
}
return false;
}
bool KateCommands::Date::exec(KTextEditor::View *view, const QString &cmd, QString &, const KTextEditor::Range &)
{
if (!cmd.startsWith(QLatin1String("date"))) {
return false;
}
if (QDateTime::currentDateTime().toString(cmd.mid(5, cmd.length() - 5)).length() > 0) {
view->document()->insertText(view->cursorPosition(), QDateTime::currentDateTime().toString(cmd.mid(5, cmd.length() - 5)));
} else {
view->document()->insertText(view->cursorPosition(), QDateTime::currentDateTime().toString(QStringLiteral("yyyy-MM-dd hh:mm:ss")));
}
return true;
}
//END Date
diff --git a/src/variableeditor/variablelineedit.cpp b/src/variableeditor/variablelineedit.cpp
index 30c8e04a..4537045f 100644
--- a/src/variableeditor/variablelineedit.cpp
+++ b/src/variableeditor/variablelineedit.cpp
@@ -1,377 +1,376 @@
/* This file is part of the KDE project
Copyright (C) 2011 Dominik Haumann
Copyright (C) 2013 Gerald Senarclens de Grancy
This library is free software; you can redistribute it and/or
modify it under the terms of the GNU Library General Public
License as published by the Free Software Foundation; either
version 2 of the License, or (at your option) any later version.
This library 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
Library General Public License for more details.
You should have received a copy of the GNU Library General Public License
along with this library; see the file COPYING.LIB. If not, write to
the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
Boston, MA 02110-1301, USA.
*/
#include "variablelineedit.h"
#include "variableitem.h"
#include "variablelistview.h"
#include "kateautoindent.h"
#include "katesyntaxmanager.h"
#include "kateschema.h"
#include "kateview.h"
#include "katedocument.h"
#include "kateglobal.h"
#include "katerenderer.h"
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
VariableLineEdit::VariableLineEdit(QWidget *parent)
: QWidget(parent)
{
m_listview = nullptr;
QHBoxLayout *hl = new QHBoxLayout();
hl->setMargin(0);
hl->setSpacing(QApplication::style()->pixelMetric(QStyle::PM_DefaultLayoutSpacing));
setLayout(hl);
m_lineedit = new QLineEdit(this);
m_button = new QToolButton(this);
m_button->setIcon(QIcon::fromTheme(QStringLiteral("tools-wizard")));
m_button->setToolTip(i18n("Show list of valid variables."));
hl->addWidget(m_lineedit);
hl->addWidget(m_button);
m_popup = new QFrame(nullptr, Qt::Popup);
m_popup->setFrameStyle(QFrame::StyledPanel | QFrame::Raised);
QVBoxLayout *l = new QVBoxLayout(m_popup);
l->setSpacing(0);
l->setMargin(0);
m_popup->setLayout(l);
// forward text changed signal
connect(m_lineedit, SIGNAL(textChanged(QString)), this, SIGNAL(textChanged(QString)));
// open popup on button click
connect(m_button, SIGNAL(clicked()), this, SLOT(editVariables()));
}
VariableLineEdit::~VariableLineEdit()
{
}
void VariableLineEdit::editVariables()
{
m_listview = new VariableListView(m_lineedit->text(), m_popup);
addKateItems(m_listview);
connect(m_listview, SIGNAL(aboutToHide()), this, SLOT(updateVariableLine()));
m_popup->layout()->addWidget(m_listview);
if (layoutDirection() == Qt::LeftToRight) {
QPoint topLeft = mapToGlobal(m_lineedit->geometry().bottomLeft());
const int w = m_button->geometry().right() - m_lineedit->geometry().left();
const int h = 300; //(w * 2) / 4;
m_popup->setGeometry(QRect(topLeft, QSize(w, h)));
} else {
QPoint topLeft = mapToGlobal(m_button->geometry().bottomLeft());
const int w = m_lineedit->geometry().right() - m_button->geometry().left();
const int h = 300; //(w * 2) / 4;
m_popup->setGeometry(QRect(topLeft, QSize(w, h)));
}
m_popup->show();
}
void VariableLineEdit::updateVariableLine()
{
QString variables = m_listview->variableLine();
m_lineedit->setText(variables);
m_popup->layout()->removeWidget(m_listview);
m_listview->deleteLater();
m_listview = nullptr;
}
void VariableLineEdit::addKateItems(VariableListView *listview)
{
VariableItem *item = nullptr;
// If a current active doc is available
KTextEditor::ViewPrivate *activeView = nullptr;
KTextEditor::DocumentPrivate *activeDoc = nullptr;
KateDocumentConfig *docConfig = KateDocumentConfig::global();
KateViewConfig *viewConfig = KateViewConfig::global();
KateRendererConfig *rendererConfig = KateRendererConfig::global();
if ((activeView = qobject_cast(KTextEditor::EditorPrivate::self()->application()->activeMainWindow()->activeView()))) {
activeDoc = activeView->doc();
viewConfig = activeView->config();
docConfig = activeDoc->config();
rendererConfig = activeView->renderer()->config();
}
// Add 'auto-brackets' to list
item = new VariableBoolItem(QStringLiteral("auto-brackets"), false);
item->setHelpText(i18nc("short translation please", "Enable automatic insertion of brackets."));
listview->addItem(item);
// Add 'auto-center-lines' to list
item = new VariableIntItem(QStringLiteral("auto-center-lines"), viewConfig->autoCenterLines());
static_cast(item)->setRange(1, 100);
item->setHelpText(i18nc("short translation please", "Set the number of autocenter lines."));
listview->addItem(item);
// Add 'background-color' to list
item = new VariableColorItem(QStringLiteral("background-color"), rendererConfig->backgroundColor());
item->setHelpText(i18nc("short translation please", "Set the document background color."));
listview->addItem(item);
// Add 'backspace-indents' to list
item = new VariableBoolItem(QStringLiteral("backspace-indents"), docConfig->backspaceIndents());
item->setHelpText(i18nc("short translation please", "Pressing backspace in leading whitespace unindents."));
listview->addItem(item);
// Add 'block-selection' to list
item = new VariableBoolItem(QStringLiteral("block-selection"), false);
if (activeView) {
static_cast(item)->setValue(activeView->blockSelection());
}
item->setHelpText(i18nc("short translation please", "Enable block selection mode."));
listview->addItem(item);
// Add 'byte-order-mark' (bom) to list
item = new VariableBoolItem(QStringLiteral("byte-order-mark"), docConfig->bom());
item->setHelpText(i18nc("short translation please", "Enable the byte order mark (BOM) when saving Unicode files."));
listview->addItem(item);
// Add 'bracket-highlight-color' to list
item = new VariableColorItem(QStringLiteral("bracket-highlight-color"), rendererConfig->highlightedBracketColor());
item->setHelpText(i18nc("short translation please", "Set the color for the bracket highlight."));
listview->addItem(item);
// Add 'current-line-color' to list
item = new VariableColorItem(QStringLiteral("current-line-color"), rendererConfig->highlightedLineColor());
item->setHelpText(i18nc("short translation please", "Set the background color for the current line."));
listview->addItem(item);
// Add 'default-dictionary' to list
Sonnet::Speller speller;
item = new VariableSpellCheckItem(QStringLiteral("default-dictionary"), speller.defaultLanguage());
item->setHelpText(i18nc("short translation please", "Set the default dictionary used for spell checking."));
listview->addItem(item);
// Add 'dynamic-word-wrap' to list
item = new VariableBoolItem(QStringLiteral("dynamic-word-wrap"), viewConfig->dynWordWrap());
item->setHelpText(i18nc("short translation please", "Enable dynamic word wrap of long lines."));
listview->addItem(item);
// Add 'end-of-line' (eol) to list
item = new VariableStringListItem(QStringLiteral("end-of-line"), { QStringLiteral("unix"), QStringLiteral("mac"), QStringLiteral("dos") }, docConfig->eolString());
item->setHelpText(i18nc("short translation please", "Sets the end of line mode."));
listview->addItem(item);
// Add 'folding-markers' to list
item = new VariableBoolItem(QStringLiteral("folding-markers"), viewConfig->foldingBar());
item->setHelpText(i18nc("short translation please", "Enable folding markers in the editor border."));
listview->addItem(item);
// Add 'folding-preview' to list
item = new VariableBoolItem(QStringLiteral("folding-preview"), viewConfig->foldingPreview());
item->setHelpText(i18nc("short translation please", "Enable folding preview in the editor border."));
listview->addItem(item);
// Add 'font-size' to list
item = new VariableIntItem(QStringLiteral("font-size"), rendererConfig->font().pointSize());
static_cast(item)->setRange(4, 128);
item->setHelpText(i18nc("short translation please", "Set the point size of the document font."));
listview->addItem(item);
// Add 'font' to list
item = new VariableFontItem(QStringLiteral("font"), rendererConfig->font());
item->setHelpText(i18nc("short translation please", "Set the font of the document."));
listview->addItem(item);
// Add 'syntax' (hl) to list
/* Prepare list of highlighting modes */
- const int count = KateHlManager::self()->highlights();
- QStringList hl;
- for (int z = 0; z < count; ++z) {
- hl << KateHlManager::self()->hlName(z);
+ QStringList hls;
+ for (const auto &hl : KateHlManager::self()->modeList()) {
+ hls << hl.name();
}
- item = new VariableStringListItem(QStringLiteral("syntax"), hl, hl.at(0));
+ item = new VariableStringListItem(QStringLiteral("syntax"), hls, hls.at(0));
if (activeDoc) {
static_cast(item)->setValue(activeDoc->highlightingMode());
}
item->setHelpText(i18nc("short translation please", "Set the syntax highlighting."));
listview->addItem(item);
// Add 'icon-bar-color' to list
item = new VariableColorItem(QStringLiteral("icon-bar-color"), rendererConfig->iconBarColor());
item->setHelpText(i18nc("short translation please", "Set the icon bar color."));
listview->addItem(item);
// Add 'icon-border' to list
item = new VariableBoolItem(QStringLiteral("icon-border"), viewConfig->iconBar());
item->setHelpText(i18nc("short translation please", "Enable the icon border in the editor view."));
listview->addItem(item);
// Add 'indent-mode' to list
item = new VariableStringListItem(QStringLiteral("indent-mode"), KateAutoIndent::listIdentifiers(), docConfig->indentationMode());
item->setHelpText(i18nc("short translation please", "Set the auto indentation style."));
listview->addItem(item);
// Add 'indent-pasted-text' to list
item = new VariableBoolItem(QStringLiteral("indent-pasted-text"), docConfig->indentPastedText());
item->setHelpText(i18nc("short translation please", "Adjust indentation of text pasted from the clipboard."));
listview->addItem(item);
// Add 'indent-width' to list
item = new VariableIntItem(QStringLiteral("indent-width"), docConfig->indentationWidth());
static_cast(item)->setRange(1, 16);
item->setHelpText(i18nc("short translation please", "Set the indentation depth for each indent level."));
listview->addItem(item);
// Add 'keep-extra-spaces' to list
item = new VariableBoolItem(QStringLiteral("keep-extra-spaces"), docConfig->keepExtraSpaces());
item->setHelpText(i18nc("short translation please", "Allow odd indentation level (no multiple of indent width)."));
listview->addItem(item);
// Add 'line-numbers' to list
item = new VariableBoolItem(QStringLiteral("line-numbers"), viewConfig->lineNumbers());
item->setHelpText(i18nc("short translation please", "Show line numbers."));
listview->addItem(item);
// Add 'newline-at-eof' to list
item = new VariableBoolItem(QStringLiteral("newline-at-eof"), docConfig->ovr());
item->setHelpText(i18nc("short translation please", "Insert newline at end of file on save."));
listview->addItem(item);
// Add 'overwrite-mode' to list
item = new VariableBoolItem(QStringLiteral("overwrite-mode"), docConfig->ovr());
item->setHelpText(i18nc("short translation please", "Enable overwrite mode in the document."));
listview->addItem(item);
// Add 'persistent-selection' to list
item = new VariableBoolItem(QStringLiteral("persistent-selection"), viewConfig->persistentSelection());
item->setHelpText(i18nc("short translation please", "Enable persistent text selection."));
listview->addItem(item);
// Add 'replace-tabs-save' to list
item = new VariableBoolItem(QStringLiteral("replace-tabs-save"), false);
item->setHelpText(i18nc("short translation please", "Replace tabs with spaces when saving the document."));
listview->addItem(item);
// Add 'replace-tabs' to list
item = new VariableBoolItem(QStringLiteral("replace-tabs"), docConfig->replaceTabsDyn());
item->setHelpText(i18nc("short translation please", "Replace tabs with spaces."));
listview->addItem(item);
// Add 'remove-trailing-spaces' to list
item = new VariableRemoveSpacesItem(QStringLiteral("remove-trailing-spaces"), docConfig->removeSpaces());
item->setHelpText(i18nc("short translation please", "Remove trailing spaces when saving the document."));
listview->addItem(item);
// Add 'scrollbar-minimap' to list
item = new VariableBoolItem(QStringLiteral("scrollbar-minimap"), viewConfig->scrollBarMiniMap());
item->setHelpText(i18nc("short translation please", "Show scrollbar minimap."));
listview->addItem(item);
// Add 'scrollbar-preview' to list
item = new VariableBoolItem(QStringLiteral("scrollbar-preview"), viewConfig->scrollBarPreview());
item->setHelpText(i18nc("short translation please", "Show scrollbar preview."));
listview->addItem(item);
// Add 'scheme' to list
QStringList schemas;
Q_FOREACH (const KateSchema &schema, KTextEditor::EditorPrivate::self()->schemaManager()->list()) {
schemas.append(schema.rawName);
}
item = new VariableStringListItem(QStringLiteral("scheme"), schemas, rendererConfig->schema());
item->setHelpText(i18nc("short translation please", "Set the color scheme."));
listview->addItem(item);
// Add 'selection-color' to list
item = new VariableColorItem(QStringLiteral("selection-color"), rendererConfig->selectionColor());
item->setHelpText(i18nc("short translation please", "Set the text selection color."));
listview->addItem(item);
// Add 'show-tabs' to list
item = new VariableBoolItem(QStringLiteral("show-tabs"), docConfig->showTabs());
item->setHelpText(i18nc("short translation please", "Visualize tabs and trailing spaces."));
listview->addItem(item);
// Add 'smart-home' to list
item = new VariableBoolItem(QStringLiteral("smart-home"), docConfig->smartHome());
item->setHelpText(i18nc("short translation please", "Enable smart home navigation."));
listview->addItem(item);
// Add 'tab-indents' to list
item = new VariableBoolItem(QStringLiteral("tab-indents"), docConfig->tabIndentsEnabled());
item->setHelpText(i18nc("short translation please", "Pressing TAB key indents."));
listview->addItem(item);
// Add 'tab-width' to list
item = new VariableIntItem(QStringLiteral("tab-width"), docConfig->tabWidth());
static_cast(item)->setRange(1, 16);
item->setHelpText(i18nc("short translation please", "Set the tab display width."));
listview->addItem(item);
// Add 'undo-steps' to list
item = new VariableIntItem(QStringLiteral("undo-steps"), 0);
static_cast(item)->setRange(0, 100);
item->setHelpText(i18nc("short translation please", "Set the number of undo steps to remember (0 equals infinity)."));
listview->addItem(item);
// Add 'word-wrap-column' to list
item = new VariableIntItem(QStringLiteral("word-wrap-column"), docConfig->wordWrapAt());
static_cast(item)->setRange(20, 200);
item->setHelpText(i18nc("short translation please", "Set the word wrap column."));
listview->addItem(item);
// Add 'word-wrap-marker-color' to list
item = new VariableColorItem(QStringLiteral("word-wrap-marker-color"), rendererConfig->wordWrapMarkerColor());
item->setHelpText(i18nc("short translation please", "Set the word wrap marker color."));
listview->addItem(item);
// Add 'word-wrap' to list
item = new VariableBoolItem(QStringLiteral("word-wrap"), docConfig->wordWrap());
item->setHelpText(i18nc("short translation please", "Enable word wrap while typing text."));
listview->addItem(item);
}
void VariableLineEdit::setText(const QString &text)
{
m_lineedit->setText(text);
}
void VariableLineEdit::clear()
{
m_lineedit->clear();
}
QString VariableLineEdit::text()
{
return m_lineedit->text();
}