Differential D17971 Diff 50673 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 "katemacroexpander.h"
27​#include "katetoolrunner.h"
28​
29​#include <KTextEditor/Document>
30​#include <KTextEditor/Editor>
31​#include <KTextEditor/View>
32​
33​#include <KConfig>
34​#include <KConfigGroup>
35​#include <KIconButton>
36​#include <KIconLoader>
37​#include <KMimeTypeChooser>
38​#include <KSharedConfig>
39​#include <KXMLGUIFactory>
40​#include <KXmlGuiWindow>
41​#include <QBitmap>
42​#include <QComboBox>
43​#include <QMenu>
44​#include <QMessageBox>
45​#include <QRegularExpression>
46​#include <QStandardItem>
47​#include <QStandardPaths>
48​#include <QTreeView>
49​
50​#include <unistd.h>
51​
52​namespace {
53​ constexpr int ToolRole = Qt::UserRole + 1;
54​
55​ /**
56​ * Helper function to create a QStandardItem that internally stores a pointer to a KateExternalTool.
57​ */
58​ QStandardItem * newToolItem(const QPixmap& icon, KateExternalTool* tool)
59​ {
60​ auto item = new QStandardItem(icon, tool->name);
61​ item->setFlags(Qt::ItemIsSelectable | Qt::ItemIsDragEnabled | Qt::ItemIsEnabled);
62​ item->setData(QVariant::fromValue(reinterpret_cast<quintptr>(tool)), ToolRole);
63​ return item;
64​ }
65​
66​ /**
67​ * Helper function to return an internally stored KateExternalTool for a QStandardItem.
68​ * If a nullptr is returned, it means the QStandardItem is a category.
69​ */
70​ KateExternalTool* toolForItem(QStandardItem* item)
71​ {
72​ return item ? reinterpret_cast<KateExternalTool*>(item->data(ToolRole).value<quintptr>()) : nullptr;
73​ }
74​}
75​
76​// BEGIN KateExternalToolServiceEditor
77​KateExternalToolServiceEditor::KateExternalToolServiceEditor(KateExternalTool* tool, QWidget* parent)
loh.tarUnsubmitted
Not Done

Existing code use //BEGIN (no space)

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

{ }

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

search

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