Differential D17971 Diff 50620 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​// BEGIN ToolItem
57​/**
58​ * This is a QStandardItem, that has a KateExternalTool.
59​ * The text is the Name of the tool.
60​ */
61​class ToolItem : public QStandardItem
62​{
63​public:
64​ ToolItem(const QPixmap& icon, KateExternalTool* tool)
65​ : QStandardItem(icon, tool->name)
66​ {
67​ setFlags(Qt::ItemIsSelectable | Qt::ItemIsDragEnabled | Qt::ItemIsEnabled);
68​ setData(QVariant::fromValue(reinterpret_cast<quintptr>(tool)), ToolRole );
69​ }
70​
71​ KateExternalTool * tool() {
72​ return reinterpret_cast<KateExternalTool*>(data(ToolRole).value<quintptr>());
73​ }
74​};
75​// END ToolItem
76​
77​// BEGIN KateExternalToolServiceEditor
loh.tarUnsubmitted
Not Done

Existing code use //BEGIN (no space)

loh.tar: Existing code use //BEGIN (no space)
78​KateExternalToolServiceEditor::KateExternalToolServiceEditor(KateExternalTool* tool, QWidget* parent)
79​ : QDialog(parent)
80​ , m_tool(tool)
81​{
82​ setWindowTitle(i18n("Edit External Tool"));
83​ setWindowIcon(QIcon::fromTheme(QStringLiteral("system-run")));
84​
85​ ui = new Ui::ToolDialog();
86​ ui->setupUi(this);
87​ ui->btnIcon->setIconSize(KIconLoader::SizeSmall);
88​
89​ connect(ui->buttonBox, &QDialogButtonBox::accepted, this, &KateExternalToolServiceEditor::slotOKClicked);
90​ connect(ui->buttonBox, &QDialogButtonBox::rejected, this, &QDialog::reject);
91​ connect(ui->btnMimeType, &QToolButton::clicked, this, &KateExternalToolServiceEditor::showMTDlg);
92​
93​ Q_ASSERT(m_tool != nullptr);
94​ ui->edtName->setText(m_tool->name);
95​ if (!m_tool->icon.isEmpty())
96​ ui->btnIcon->setIcon(m_tool->icon);
97​
98​ ui->edtExecutable->setText(m_tool->executable);
99​ ui->edtArgs->setText(m_tool->arguments);
100​ ui->edtInput->setText(m_tool->input);
101​ ui->edtWorkingDir->setText(m_tool->workingDir);
102​ ui->edtMimeType->setText(m_tool->mimetypes.join(QStringLiteral("; ")));
103​ ui->cmbSave->setCurrentIndex(static_cast<int>(m_tool->saveMode));
104​ ui->chkReload->setChecked(m_tool->reload);
105​ ui->cmbOutput->setCurrentIndex(static_cast<int>(m_tool->outputMode));
106​ ui->chkIncludeStderr->setChecked(m_tool->includeStderr);
107​ ui->edtCommand->setText(m_tool->cmdname);
108​}
109​
110​void KateExternalToolServiceEditor::slotOKClicked()
111​{
112​ if (ui->edtName->text().isEmpty() || ui->edtExecutable->text().isEmpty()) {
113​ QMessageBox::information(this, i18n("External Tool"),
114​ i18n("You must specify at least a name and an executable"));
115​ return;
116​ }
117​ accept();
118​}
119​
120​void KateExternalToolServiceEditor::showMTDlg()
121​{
122​ QString text = i18n("Select the MimeTypes for which to enable this tool.");
123​ QStringList list
124​ = ui->edtMimeType->text().split(QRegularExpression(QStringLiteral("\\s*;\\s*")), QString::SkipEmptyParts);
125​ KMimeTypeChooserDialog d(i18n("Select Mime Types"), text, list, QStringLiteral("text"), this);
126​ if (d.exec() == QDialog::Accepted) {
127​ ui->edtMimeType->setText(d.chooser()->mimeTypes().join(QStringLiteral(";")));
128​ }
129​}
130​// END KateExternalToolServiceEditor
131​
132​static std::vector<QStandardItem*> childItems(const QStandardItem * item)
133​{
134​ // collect all KateExternalTool items
135​ std::vector<QStandardItem*> children;
136​ for (int i = 0; i < item->rowCount(); ++i) {
137​ children.push_back(item->child(i));
138​ }
139​ return children;
140​}
141​
142​static std::vector<KateExternalTool*> collectTools(const QStandardItemModel & model)
143​{
144​ std::vector<KateExternalTool*> tools;
145​ for (auto categoryItem : childItems(model.invisibleRootItem())) {
146​ for (auto child : childItems(categoryItem)) {
147​ auto toolItem = static_cast<ToolItem*>(child);
148​ tools.push_back(toolItem->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 = new ToolItem(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 toolItem = static_cast<ToolItem*>(child);
loh.tarUnsubmitted
Not Done

{ }

loh.tar: { }
259​ auto tool = toolItem->tool();
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 = dynamic_cast<ToolItem*>(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 toolItem = dynamic_cast<ToolItem*>(item);
350​ if (toolItem) {
351​ // the parent of a ToolItem is always a category
352​ return toolItem->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 = new ToolItem(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 toolItem = dynamic_cast<ToolItem*>(item);
422​
423​ if (toolItem) {
424​ auto tool = toolItem->tool();
425​ toolItem->parent()->removeRow(toolItem->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 toolItem = dynamic_cast<ToolItem*>(item);
436​ if (!toolItem) {
437​ if (item) {
438​ lbTools->edit(item->index());
439​ }
440​ return;
441​ }
442​ // show the item in an editor
443​ KateExternalTool* t = toolItem->tool();
444​ if (editTool(t)) {
445​ // renew the icon and name
446​ toolItem->setText(t->name);
447​ toolItem->setIcon(t->icon.isEmpty() ? blankIcon() : SmallIcon(t->icon));
448​
449​ Q_EMIT changed();
450​ m_changed = true;
451​ }
452​}
453​// END KateExternalToolsConfigWidget
454​
455​// kate: space-indent on; indent-width 4; replace-tabs on;