Differential D17971 Diff 50912 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->edtCommand->setText(m_tool->cmdname);
106​}
107​
108​void KateExternalToolServiceEditor::slotOKClicked()
109​{
110​ if (ui->edtName->text().isEmpty() || ui->edtExecutable->text().isEmpty()) {
111​ QMessageBox::information(this, i18n("External Tool"),
112​ i18n("You must specify at least a name and an executable"));
113​ return;
114​ }
115​ accept();
116​}
117​
118​void KateExternalToolServiceEditor::showMTDlg()
119​{
120​ QString text = i18n("Select the MimeTypes for which to enable this tool.");
121​ QStringList list
122​ = ui->edtMimeType->text().split(QRegularExpression(QStringLiteral("\\s*;\\s*")), QString::SkipEmptyParts);
123​ KMimeTypeChooserDialog d(i18n("Select Mime Types"), text, list, QStringLiteral("text"), this);
124​ if (d.exec() == QDialog::Accepted) {
125​ ui->edtMimeType->setText(d.chooser()->mimeTypes().join(QStringLiteral(";")));
126​ }
127​}
128​// END KateExternalToolServiceEditor
129​
130​static std::vector<QStandardItem*> childItems(const QStandardItem * item)
131​{
132​ // collect all KateExternalTool items
133​ std::vector<QStandardItem*> children;
134​ for (int i = 0; i < item->rowCount(); ++i) {
135​ children.push_back(item->child(i));
136​ }
137​ return children;
138​}
139​
140​static std::vector<KateExternalTool*> collectTools(const QStandardItemModel & model)
141​{
142​ std::vector<KateExternalTool*> tools;
143​ for (auto categoryItem : childItems(model.invisibleRootItem())) {
144​ for (auto child : childItems(categoryItem)) {
145​ auto tool = toolForItem(child);
146​ Q_ASSERT(tool != nullptr);
147​ tools.push_back(tool);
148​ }
149​ }
150​ return tools;
151​}
152​
153​// BEGIN KateExternalToolsConfigWidget
154​KateExternalToolsConfigWidget::KateExternalToolsConfigWidget(QWidget* parent, KateExternalToolsPlugin* plugin)
155​ : KTextEditor::ConfigPage(parent)
156​ , m_plugin(plugin)
157​{
158​ setupUi(this);
159​ layout()->setMargin(0);
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->cmdname = editor.ui->edtCommand->text();
308​
309​ // sticky action collection name, never changes again, so that shortcuts stay
310​ tool->actionName = QStringLiteral("externaltool_") + QString(tool->name).remove(QRegularExpression(QStringLiteral("\\W+")));
311​
312​ changed = true;
313​ }
314​
315​ m_config->group("Editor").writeEntry("Size", editor.size());
316​ m_config->sync();
317​
318​ return changed;
319​}
320​
321​QStandardItem * KateExternalToolsConfigWidget::addCategory(const QString & category)
322​{
323​ // searach for existing category
324​ auto items = m_toolsModel.findItems(category);
325​ if (!items.empty()) {
326​ return items.front();
327​ }
328​
329​ // ...otherwise, create it
330​ auto item = new QStandardItem(category);
331​
loh.tarUnsubmitted
Not Done

search

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