Differential D17971 Diff 54071 addons/externaltools/kateexternaltoolsconfigwidget.cpp

Changeset View

Standalone View

View Options

addons/externaltools/kateexternaltoolsconfigwidget.cpp

  • This file was added.
1​/* This file is part of the KDE project
2​ *
3​ * Copyright 2019 Dominik Haumann <dhaumann@kde.org>
4​ *
5​ * This library is free software; you can redistribute it and/or
6​ * modify it under the terms of the GNU Library General Public
7​ * License as published by the Free Software Foundation; either
8​ * version 2 of the License, or (at your option) any later version.
9​ *
10​ * This library is distributed in the hope that it will be useful,
11​ * but WITHOUT ANY WARRANTY; without even the implied warranty of
12​ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
13​ * Library General Public License for more details.
14​ *
15​ * You should have received a copy of the GNU Library General Public License
16​ * along with this library; see the file COPYING.LIB. If not, write to
17​ * the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
18​ * Boston, MA 02110-1301, USA.
19​ */
20​// TODO
21​// Icons
22​// Direct shortcut setting
23​#include "kateexternaltoolsconfigwidget.h"
24​#include "externaltoolsplugin.h"
25​#include "kateexternaltool.h"
26​#include "katetoolrunner.h"
27​
28​#include <KTextEditor/Document>
29​#include <KTextEditor/Editor>
30​#include <KTextEditor/View>
31​
32​#include <KConfig>
33​#include <KConfigGroup>
34​#include <KIconButton>
35​#include <KIconLoader>
36​#include <KMimeTypeChooser>
37​#include <KSharedConfig>
38​#include <KXMLGUIFactory>
39​#include <KXmlGuiWindow>
40​#include <QBitmap>
41​#include <QComboBox>
42​#include <QMenu>
43​#include <QMessageBox>
44​#include <QRegularExpression>
45​#include <QStandardItem>
46​#include <QStandardPaths>
47​#include <QTreeView>
48​
49​#include <unistd.h>
50​
51​namespace {
52​ constexpr int ToolRole = Qt::UserRole + 1;
53​
54​ /**
55​ * Helper function to create a QStandardItem that internally stores a pointer to a KateExternalTool.
56​ */
57​ QStandardItem * newToolItem(const QPixmap& icon, KateExternalTool* tool)
58​ {
59​ auto item = new QStandardItem(icon, tool->name);
60​ item->setFlags(Qt::ItemIsSelectable | Qt::ItemIsDragEnabled | Qt::ItemIsEnabled);
61​ item->setData(QVariant::fromValue(reinterpret_cast<quintptr>(tool)), ToolRole);
62​ return item;
63​ }
64​
65​ /**
66​ * Helper function to return an internally stored KateExternalTool for a QStandardItem.
67​ * If a nullptr is returned, it means the QStandardItem is a category.
68​ */
69​ KateExternalTool* toolForItem(QStandardItem* item)
70​ {
71​ return item ? reinterpret_cast<KateExternalTool*>(item->data(ToolRole).value<quintptr>()) : nullptr;
72​ }
73​}
74​
75​// BEGIN KateExternalToolServiceEditor
76​KateExternalToolServiceEditor::KateExternalToolServiceEditor(KateExternalTool* tool, QWidget* parent)
77​ : QDialog(parent)
loh.tarUnsubmitted
Not Done

Existing code use //BEGIN (no space)

loh.tar: Existing code use //BEGIN (no space)
78​ , m_tool(tool)
79​{
80​ setWindowTitle(i18n("Edit External Tool"));
81​ setWindowIcon(QIcon::fromTheme(QStringLiteral("system-run")));
82​
83​ ui = new Ui::ToolDialog();
84​ ui->setupUi(this);
85​ ui->btnIcon->setIconSize(KIconLoader::SizeSmall);
86​
87​ auto contextAction = new ContextAction(QIcon::fromTheme(QStringLiteral("code-context"), QIcon::fromTheme(QStringLiteral("tools-wizard"))),
88​ QStringLiteral("Insert variable"), this);
89​ contextAction->attachTo(ui->edtExecutable);
90​ contextAction->attachTo(ui->edtArgs);
91​// contextAction->attachTo(ui->edtInput); // not a QLineEdit
92​ contextAction->attachTo(ui->edtWorkingDir);
93​
94​ connect(ui->buttonBox, &QDialogButtonBox::accepted, this, &KateExternalToolServiceEditor::slotOKClicked);
95​ connect(ui->buttonBox, &QDialogButtonBox::rejected, this, &QDialog::reject);
96​ connect(ui->btnMimeType, &QToolButton::clicked, this, &KateExternalToolServiceEditor::showMTDlg);
97​
98​ Q_ASSERT(m_tool != nullptr);
99​ ui->edtName->setText(m_tool->name);
100​ if (!m_tool->icon.isEmpty())
101​ ui->btnIcon->setIcon(m_tool->icon);
102​
103​ ui->edtExecutable->setText(m_tool->executable);
104​ ui->edtArgs->setText(m_tool->arguments);
105​ ui->edtInput->setText(m_tool->input);
106​ ui->edtWorkingDir->setText(m_tool->workingDir);
107​ ui->edtMimeType->setText(m_tool->mimetypes.join(QStringLiteral("; ")));
108​ ui->cmbSave->setCurrentIndex(static_cast<int>(m_tool->saveMode));
109​ ui->chkReload->setChecked(m_tool->reload);
110​ ui->cmbOutput->setCurrentIndex(static_cast<int>(m_tool->outputMode));
111​ ui->edtCommand->setText(m_tool->cmdname);
112​}
113​
114​void KateExternalToolServiceEditor::slotOKClicked()
115​{
116​ if (ui->edtName->text().isEmpty() || ui->edtExecutable->text().isEmpty()) {
117​ QMessageBox::information(this, i18n("External Tool"),
118​ i18n("You must specify at least a name and an executable"));
119​ return;
120​ }
121​ accept();
122​}
123​
124​void KateExternalToolServiceEditor::showMTDlg()
125​{
126​ QString text = i18n("Select the MimeTypes for which to enable this tool.");
127​ QStringList list
128​ = ui->edtMimeType->text().split(QRegularExpression(QStringLiteral("\\s*;\\s*")), QString::SkipEmptyParts);
129​ KMimeTypeChooserDialog d(i18n("Select Mime Types"), text, list, QStringLiteral("text"), this);
130​ if (d.exec() == QDialog::Accepted) {
131​ ui->edtMimeType->setText(d.chooser()->mimeTypes().join(QStringLiteral(";")));
132​ }
133​}
134​// END KateExternalToolServiceEditor
135​
136​static std::vector<QStandardItem*> childItems(const QStandardItem * item)
137​{
138​ // collect all KateExternalTool items
139​ std::vector<QStandardItem*> children;
140​ for (int i = 0; i < item->rowCount(); ++i) {
141​ children.push_back(item->child(i));
142​ }
143​ return children;
144​}
145​
146​static std::vector<KateExternalTool*> collectTools(const QStandardItemModel & model)
147​{
148​ std::vector<KateExternalTool*> tools;
149​ for (auto categoryItem : childItems(model.invisibleRootItem())) {
150​ for (auto child : childItems(categoryItem)) {
151​ auto tool = toolForItem(child);
152​ Q_ASSERT(tool != nullptr);
153​ tools.push_back(tool);
154​ }
155​ }
156​ return tools;
157​}
158​
159​// BEGIN KateExternalToolsConfigWidget
160​KateExternalToolsConfigWidget::KateExternalToolsConfigWidget(QWidget* parent, KateExternalToolsPlugin* plugin)
161​ : KTextEditor::ConfigPage(parent)
162​ , m_plugin(plugin)
163​{
164​ setupUi(this);
165​ layout()->setMargin(0);
166​ lbTools->setModel(&m_toolsModel);
167​ lbTools->setSelectionMode(QAbstractItemView::SingleSelection);
168​ lbTools->setDragEnabled(true);
169​ lbTools->setAcceptDrops(true);
170​ lbTools->setDefaultDropAction(Qt::MoveAction);
171​ lbTools->setDropIndicatorShown(true);
172​ lbTools->setDragDropOverwriteMode(false);
173​ lbTools->setDragDropMode(QAbstractItemView::InternalMove);
174​
175​ // Add... button popup menu
176​ auto addMenu = new QMenu();
177​ auto addToolAction = addMenu->addAction(i18n("Add Tool..."));
178​ auto addCategoryAction = addMenu->addAction(i18n("Add Category"));
179​ btnAdd->setMenu(addMenu);
180​
181​ connect(addCategoryAction, &QAction::triggered, this, &KateExternalToolsConfigWidget::slotAddCategory);
182​ connect(addToolAction, &QAction::triggered, this, &KateExternalToolsConfigWidget::slotAddTool);
183​ connect(btnRemove, &QPushButton::clicked, this, &KateExternalToolsConfigWidget::slotRemove);
184​ connect(btnEdit, &QPushButton::clicked, this, &KateExternalToolsConfigWidget::slotEdit);
185​ connect(lbTools->selectionModel(), &QItemSelectionModel::currentChanged, [this](){
186​ slotSelectionChanged();
187​ });
188​ connect(lbTools, &QTreeView::doubleClicked, this, &KateExternalToolsConfigWidget::slotEdit);
189​
190​ m_config = new KConfig(QStringLiteral("externaltools"), KConfig::NoGlobals, QStandardPaths::ApplicationsLocation);
191​
192​ // reset triggers a reload of the existing tools
193​ reset();
194​ slotSelectionChanged();
195​
196​ connect(&m_toolsModel, &QStandardItemModel::itemChanged, [this](){
197​ m_changed = true;
198​ Q_EMIT changed();
199​ });
200​}
201​
202​KateExternalToolsConfigWidget::~KateExternalToolsConfigWidget()
203​{
204​ clearTools();
205​
206​ delete m_config;
207​}
208​
209​QString KateExternalToolsConfigWidget::name() const
210​{
211​ return i18n("External Tools");
212​}
213​
214​QString KateExternalToolsConfigWidget::fullName() const
215​{
216​ return i18n("External Tools");
217​}
218​
219​QIcon KateExternalToolsConfigWidget::icon() const
220​{
221​ return QIcon::fromTheme(QStringLiteral("system-run"));
222​}
223​
224​void KateExternalToolsConfigWidget::reset()
225​{
226​ clearTools();
227​ m_toolsModel.invisibleRootItem()->setFlags(Qt::NoItemFlags);
228​
229​ // the "Uncategorized" category always exists
230​ m_noCategory = addCategory(i18n("Uncategorized"));
231​ m_noCategory->setFlags(Qt::ItemIsSelectable | Qt::ItemIsDropEnabled | Qt::ItemIsEnabled);
232​
233​ // create other tools and categories
234​ const auto tools = m_plugin->tools();
235​ for (auto tool : tools) {
236​ auto clone = new KateExternalTool(*tool);
237​ auto item = newToolItem(clone->icon.isEmpty() ? blankIcon() : SmallIcon(clone->icon), clone);
238​ auto category = clone->category.isEmpty() ? m_noCategory : addCategory(clone->category);
239​ category->appendRow(item);
240​ }
241​ lbTools->expandAll();
242​ m_changed = false;
243​}
244​
245​QPixmap KateExternalToolsConfigWidget::blankIcon()
246​{
247​ QPixmap pm(KIconLoader::SizeSmall, KIconLoader::SizeSmall);
248​ pm.fill();
249​ pm.setMask(pm.createHeuristicMask());
250​ return pm;
251​}
252​
253​void KateExternalToolsConfigWidget::apply()
254​{
255​ if (!m_changed)
256​ return;
257​ m_changed = false;
258​
loh.tarUnsubmitted
Not Done

{ }

loh.tar: { }
259​ // collect all KateExternalTool items
260​ std::vector<KateExternalTool*> tools;
261​ for (auto categoryItem : childItems(m_toolsModel.invisibleRootItem())) {
262​ const QString category = (categoryItem == m_noCategory) ? QString() : categoryItem->text();
263​ for (auto child : childItems(categoryItem)) {
264​ auto tool = toolForItem(child);
265​ Q_ASSERT(tool != nullptr);
266​ // at this point, we have to overwrite the category, since it may have changed (and we never tracked this)
267​ tool->category = category;
268​ tools.push_back(tool);
269​ }
270​ }
271​
272​ // write tool configuration to disk
273​ m_config->group("Global").writeEntry("tools", static_cast<int>(tools.size()));
274​ for (size_t i = 0; i < tools.size(); i++) {
275​ const QString section = QStringLiteral("Tool ") + QString::number(i);
276​ KConfigGroup cg(m_config, section);
277​ tools[i]->save(cg);
278​ }
279​
280​ m_config->sync();
281​ m_plugin->reload();
282​}
283​
284​void KateExternalToolsConfigWidget::slotSelectionChanged()
285​{
286​ // update button state
287​ auto item = m_toolsModel.itemFromIndex(lbTools->currentIndex());
288​ const bool isToolItem = toolForItem(item) != nullptr;
289​ const bool isCategory = item && !isToolItem;
290​
291​ btnEdit->setEnabled(isToolItem || isCategory);
292​ btnRemove->setEnabled(isToolItem);
293​}
294​
295​bool KateExternalToolsConfigWidget::editTool(KateExternalTool* tool)
296​{
297​ bool changed = false;
298​
299​ KateExternalToolServiceEditor editor(tool, this);
300​ editor.resize(m_config->group("Editor").readEntry("Size", QSize()));
301​ if (editor.exec() == QDialog::Accepted) {
302​ tool->name = editor.ui->edtName->text();
303​ tool->icon = editor.ui->btnIcon->icon();
304​ tool->executable = editor.ui->edtExecutable->text();
305​ tool->arguments = editor.ui->edtArgs->text();
306​ tool->input = editor.ui->edtInput->toPlainText();
307​ tool->workingDir = editor.ui->edtWorkingDir->text();
308​ tool->mimetypes = editor.ui->edtMimeType->text().split(QRegularExpression(QStringLiteral("\\s*;\\s*")),
309​ QString::SkipEmptyParts);
310​ tool->saveMode = static_cast<KateExternalTool::SaveMode>(editor.ui->cmbSave->currentIndex());
311​ tool->reload = editor.ui->chkReload->isChecked();
312​ tool->outputMode = static_cast<KateExternalTool::OutputMode>(editor.ui->cmbOutput->currentIndex());
313​ tool->cmdname = editor.ui->edtCommand->text();
314​
315​ // sticky action collection name, never changes again, so that shortcuts stay
316​ tool->actionName = QStringLiteral("externaltool_") + QString(tool->name).remove(QRegularExpression(QStringLiteral("\\W+")));
317​
318​ changed = true;
319​ }
320​
321​ m_config->group("Editor").writeEntry("Size", editor.size());
322​ m_config->sync();
323​
324​ return changed;
325​}
326​
327​QStandardItem * KateExternalToolsConfigWidget::addCategory(const QString & category)
328​{
329​ // searach for existing category
330​ auto items = m_toolsModel.findItems(category);
331​ if (!items.empty()) {
loh.tarUnsubmitted
Not Done

search

loh.tar: search
332​ return items.front();
333​ }
334​
335​ // ...otherwise, create it
336​ auto item = new QStandardItem(category);
337​
338​ // for now, categories are not movable, otherwise, the use can move a
339​ // category into another category, which is not supported right now
340​ item->setFlags(Qt::ItemIsSelectable | Qt::ItemIsDropEnabled | Qt::ItemIsEnabled | Qt::ItemIsEditable);
341​
342​ m_toolsModel.appendRow(item);
343​ return item;
344​}
345​
346​QStandardItem * KateExternalToolsConfigWidget::currentCategory() const
347​{
348​ auto index = lbTools->currentIndex();
349​ if (!index.isValid()) {
350​ return m_noCategory;
351​ }
352​
353​ auto item = m_toolsModel.itemFromIndex(index);
354​ auto tool = toolForItem(item);
355​ if (tool) {
356​ // the parent of a ToolItem is always a category
357​ return item->parent();
358​ }
359​
360​ // item is no ToolItem, so we must have a category at hand
361​ return item;
362​}
363​
364​void KateExternalToolsConfigWidget::clearTools()
365​{
366​ // collect all KateExternalTool items and delete them, since they are copies
367​ std::vector<KateExternalTool*> tools = collectTools(m_toolsModel);
368​ qDeleteAll(tools);
369​ tools.clear();
370​ m_toolsModel.clear();
371​}
372​
373​void KateExternalToolsConfigWidget::slotAddCategory()
374​{
375​ // find unique name
376​ QString name = i18n("New Category");
377​ int i = 1;
378​ while (!m_toolsModel.findItems(name, Qt::MatchFixedString).isEmpty()) {
379​ name = (i18n("New Category %1", i++));
380​ }
381​
382​ // add category and switch to edit mode
383​ auto item = addCategory(name);
384​ lbTools->edit(item->index());
385​}
386​
387​//! Helper that ensures that tool->actionName is unique
388​static void makeActionNameUnique(KateExternalTool* tool, const std::vector<KateExternalTool*> & tools)
389​{
390​ QString name = tool->actionName;
391​ int i = 1;
392​ bool notUnique = true;
393​ while (notUnique) {
394​ auto it = std::find_if(tools.cbegin(), tools.cend(), [&name](const KateExternalTool* tool) {
395​ return tool->actionName == name;
396​ });
397​ if (it == tools.cend()) {
398​ break;
399​ }
400​ name = tool->actionName + QString::number(i);
401​ ++i;
402​ }
403​ tool->actionName = name;
404​}
405​
406​void KateExternalToolsConfigWidget::slotAddTool()
407​{
408​ auto t = new KateExternalTool();
409​ if (editTool(t)) {
410​ makeActionNameUnique(t, collectTools(m_toolsModel));
411​ auto item = newToolItem(t->icon.isEmpty() ? blankIcon() : SmallIcon(t->icon), t);
412​ auto category = currentCategory();
413​ category->appendRow(item);
414​ lbTools->setCurrentIndex(item->index());
415​
416​ Q_EMIT changed();
417​ m_changed = true;
418​ } else {
419​ delete t;
420​ }
421​}
422​
423​void KateExternalToolsConfigWidget::slotRemove()
424​{
425​ auto item = m_toolsModel.itemFromIndex(lbTools->currentIndex());
426​ auto tool = toolForItem(item);
427​
428​ if (tool) {
429​ item->parent()->removeRow(item->index().row());
430​ delete tool;
431​ Q_EMIT changed();
432​ m_changed = true;
433​ }
434​}
435​
436​void KateExternalToolsConfigWidget::slotEdit()
437​{
438​ auto item = m_toolsModel.itemFromIndex(lbTools->currentIndex());
439​ auto tool = toolForItem(item);
440​ if (!tool) {
441​ if (item) {
442​ lbTools->edit(item->index());
443​ }
444​ return;
445​ }
446​ // show the item in an editor
447​ if (editTool(tool)) {
448​ // renew the icon and name
449​ item->setText(tool->name);
450​ item->setIcon(tool->icon.isEmpty() ? blankIcon() : SmallIcon(tool->icon));
451​
452​ Q_EMIT changed();
453​ m_changed = true;
454​ }
455​}
456​// END KateExternalToolsConfigWidget
457​
458​
459​ContextAction::ContextAction(const QIcon & icon, const QString & text, QObject * parent)
460​ : QObject(parent)
461​ , m_action(new QAction(icon, text, this))
462​{
463​ connect(m_action, &QAction::triggered, [this]() {
464​ if (m_currentLineEdit) {
465​ Q_EMIT triggered(m_currentLineEdit);
466​ }
467​ });
468​}
469​
470​void ContextAction::attachTo(QLineEdit * lineEdit)
471​{
472​ lineEdit->installEventFilter(this);
473​}
474​
475​bool ContextAction::eventFilter(QObject *watched, QEvent *event)
476​{
477​ auto lineEdit = qobject_cast<QLineEdit*>(watched);
478​ if (lineEdit) {
479​ if (event->type() == QEvent::FocusOut) {
480​ lineEdit->removeAction(m_action);
481​ m_currentLineEdit = nullptr;
482​ }
483​ else if (event->type() == QEvent::FocusIn) {
484​ m_currentLineEdit = lineEdit;
485​ lineEdit->addAction(m_action, QLineEdit::TrailingPosition);
486​ }
487​ }
488​ return false;
489​}
490​
491​// kate: space-indent on; indent-width 4; replace-tabs on;