Differential D17971 Diff 50859 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​ layout()->setMargin(0);
161​ lbTools->setModel(&m_toolsModel);
162​ lbTools->setSelectionMode(QAbstractItemView::SingleSelection);
163​ lbTools->setDragEnabled(true);
164​ lbTools->setAcceptDrops(true);
165​ lbTools->setDefaultDropAction(Qt::MoveAction);
166​ lbTools->setDropIndicatorShown(true);
167​ lbTools->setDragDropOverwriteMode(false);
168​ lbTools->setDragDropMode(QAbstractItemView::InternalMove);
169​
170​ // Add... button popup menu
171​ auto addMenu = new QMenu();
172​ auto addToolAction = addMenu->addAction(i18n("Add Tool..."));
173​ auto addCategoryAction = addMenu->addAction(i18n("Add Category"));
174​ btnAdd->setMenu(addMenu);
175​
176​ connect(addCategoryAction, &QAction::triggered, this, &KateExternalToolsConfigWidget::slotAddCategory);
177​ connect(addToolAction, &QAction::triggered, this, &KateExternalToolsConfigWidget::slotAddTool);
178​ connect(btnRemove, &QPushButton::clicked, this, &KateExternalToolsConfigWidget::slotRemove);
179​ connect(btnEdit, &QPushButton::clicked, this, &KateExternalToolsConfigWidget::slotEdit);
180​ connect(lbTools->selectionModel(), &QItemSelectionModel::currentChanged, [this](){
181​ slotSelectionChanged();
182​ });
183​ connect(lbTools, &QTreeView::doubleClicked, this, &KateExternalToolsConfigWidget::slotEdit);
184​
185​ m_config = new KConfig(QStringLiteral("externaltools"), KConfig::NoGlobals, QStandardPaths::ApplicationsLocation);
186​
187​ // reset triggers a reload of the existing tools
188​ reset();
189​ slotSelectionChanged();
190​
191​ connect(&m_toolsModel, &QStandardItemModel::itemChanged, [this](){
192​ m_changed = true;
193​ Q_EMIT changed();
194​ });
195​}
196​
197​KateExternalToolsConfigWidget::~KateExternalToolsConfigWidget()
198​{
199​ clearTools();
200​
201​ delete m_config;
202​}
203​
204​QString KateExternalToolsConfigWidget::name() const
205​{
206​ return i18n("External Tools");
207​}
208​
209​QString KateExternalToolsConfigWidget::fullName() const
210​{
211​ return i18n("External Tools");
212​}
213​
214​QIcon KateExternalToolsConfigWidget::icon() const
215​{
216​ return QIcon::fromTheme(QStringLiteral("system-run"));
217​}
218​
219​void KateExternalToolsConfigWidget::reset()
220​{
221​ clearTools();
222​ m_toolsModel.invisibleRootItem()->setFlags(Qt::NoItemFlags);
223​
224​ // the "Uncategorized" category always exists
225​ m_noCategory = addCategory(i18n("Uncategorized"));
226​ m_noCategory->setFlags(Qt::ItemIsSelectable | Qt::ItemIsDropEnabled | Qt::ItemIsEnabled);
227​
228​ // create other tools and categories
229​ const auto tools = m_plugin->tools();
230​ for (auto tool : tools) {
231​ auto clone = new KateExternalTool(*tool);
232​ auto item = newToolItem(clone->icon.isEmpty() ? blankIcon() : SmallIcon(clone->icon), clone);
233​ auto category = clone->category.isEmpty() ? m_noCategory : addCategory(clone->category);
234​ category->appendRow(item);
235​ }
236​ lbTools->expandAll();
237​ m_changed = false;
238​}
239​
240​QPixmap KateExternalToolsConfigWidget::blankIcon()
241​{
242​ QPixmap pm(KIconLoader::SizeSmall, KIconLoader::SizeSmall);
243​ pm.fill();
244​ pm.setMask(pm.createHeuristicMask());
245​ return pm;
246​}
247​
248​void KateExternalToolsConfigWidget::apply()
249​{
250​ if (!m_changed)
251​ return;
252​ m_changed = false;
253​
254​ // collect all KateExternalTool items
255​ std::vector<KateExternalTool*> tools;
256​ for (auto categoryItem : childItems(m_toolsModel.invisibleRootItem())) {
257​ const QString category = (categoryItem == m_noCategory) ? QString() : categoryItem->text();
258​ for (auto child : childItems(categoryItem)) {
loh.tarUnsubmitted
Not Done

{ }

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

search

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