Differential D17971 Diff 50143 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 <KActionCollection>
34​#include <KConfig>
35​#include <KConfigGroup>
36​#include <KIconButton>
37​#include <KIconLoader>
38​#include <KMessageBox>
39​#include <KMimeTypeChooser>
40​#include <KSharedConfig>
41​#include <KXMLGUIFactory>
42​#include <KXmlGuiWindow>
43​#include <QComboBox>
44​#include <QLineEdit>
45​#include <QListWidget>
46​#include <QMenu>
47​#include <QStandardPaths>
48​
49​#include <QBitmap>
50​#include <QFile>
51​#include <QGridLayout>
52​#include <QLabel>
53​#include <QObject>
54​#include <QPushButton>
55​#include <QRegularExpression>
56​#include <QTextEdit>
57​#include <QToolButton>
58​
59​#include <unistd.h>
60​
61​// BEGIN ToolItem
62​/**
63​ * This is a QListBoxItem, that has a KateExternalTool. The text is the Name
64​ * of the tool.
65​ */
66​class ToolItem : public QListWidgetItem
67​{
68​public:
69​ ToolItem(QListWidget* lb, const QPixmap& icon, KateExternalTool* tool)
70​ : QListWidgetItem(icon, tool->name, lb)
71​ , tool(tool)
72​ {
73​ }
74​
75​ ~ToolItem() {}
76​
77​ KateExternalTool* tool;
loh.tarUnsubmitted
Not Done

Existing code use //BEGIN (no space)

loh.tar: Existing code use //BEGIN (no space)
78​};
79​// END ToolItem
80​
81​// BEGIN KateExternalToolServiceEditor
82​KateExternalToolServiceEditor::KateExternalToolServiceEditor(KateExternalTool* tool, QWidget* parent)
83​ : QDialog(parent)
84​ , tool(tool)
85​{
86​ setWindowTitle(i18n("Edit External Tool"));
87​
88​ ui = new Ui::ToolDialog();
89​ ui->setupUi(this);
90​ ui->btnIcon->setIconSize(KIconLoader::SizeSmall);
91​
92​ connect(ui->buttonBox, &QDialogButtonBox::accepted, this, &KateExternalToolServiceEditor::slotOKClicked);
93​ connect(ui->buttonBox, &QDialogButtonBox::rejected, this, &QDialog::reject);
94​ connect(ui->btnMimeType, &QToolButton::clicked, this, &KateExternalToolServiceEditor::showMTDlg);
95​
96​ if (tool) {
97​ ui->edtName->setText(tool->name);
98​ if (!tool->icon.isEmpty())
99​ ui->btnIcon->setIcon(tool->icon);
100​
101​ ui->edtExecutable->setText(tool->executable);
102​ ui->edtArgs->setText(tool->arguments);
103​ ui->edtInput->setText(tool->input);
104​ ui->edtCommand->setText(tool->cmdname);
105​ ui->edtWorkingDir->setText(tool->workingDir);
106​ ui->edtMimeType->setText(tool->mimetypes.join(QStringLiteral("; ")));
107​ ui->cmbSave->setCurrentIndex(static_cast<int>(tool->saveMode));
108​ ui->chkIncludeStderr->setChecked(tool->includeStderr);
109​ }
110​}
111​
112​void KateExternalToolServiceEditor::slotOKClicked()
113​{
114​ if (ui->edtName->text().isEmpty() || ui->edtExecutable->text().isEmpty()) {
115​ QMessageBox::information(this, i18n("External Tool"),
116​ i18n("You must specify at least a name and an executable"));
117​ return;
118​ }
119​ accept();
120​}
121​
122​void KateExternalToolServiceEditor::showMTDlg()
123​{
124​ QString text = i18n("Select the MimeTypes for which to enable this tool.");
125​ QStringList list
126​ = ui->edtMimeType->text().split(QRegularExpression(QStringLiteral("\\s*;\\s*")), QString::SkipEmptyParts);
127​ KMimeTypeChooserDialog d(i18n("Select Mime Types"), text, list, QStringLiteral("text"), this);
128​ if (d.exec() == QDialog::Accepted) {
129​ ui->edtMimeType->setText(d.chooser()->mimeTypes().join(QStringLiteral(";")));
130​ }
131​}
132​// END KateExternalToolServiceEditor
133​
134​// BEGIN KateExternalToolsConfigWidget
135​KateExternalToolsConfigWidget::KateExternalToolsConfigWidget(QWidget* parent, KateExternalToolsPlugin* plugin)
136​ : KTextEditor::ConfigPage(parent)
137​ , m_plugin(plugin)
138​{
139​ setupUi(this);
140​
141​ btnMoveUp->setIcon(QIcon::fromTheme(QStringLiteral("go-up")));
142​ btnMoveDown->setIcon(QIcon::fromTheme(QStringLiteral("go-down")));
143​
144​ connect(lbTools, &QListWidget::itemSelectionChanged, this, &KateExternalToolsConfigWidget::slotSelectionChanged);
145​ connect(lbTools, &QListWidget::itemDoubleClicked, this, &KateExternalToolsConfigWidget::slotEdit);
146​ connect(btnNew, &QPushButton::clicked, this, &KateExternalToolsConfigWidget::slotNew);
147​ connect(btnRemove, &QPushButton::clicked, this, &KateExternalToolsConfigWidget::slotRemove);
148​ connect(btnEdit, &QPushButton::clicked, this, &KateExternalToolsConfigWidget::slotEdit);
149​ connect(btnMoveUp, &QPushButton::clicked, this, &KateExternalToolsConfigWidget::slotMoveUp);
150​ connect(btnMoveDown, &QPushButton::clicked, this, &KateExternalToolsConfigWidget::slotMoveDown);
151​
152​ m_config = new KConfig(QStringLiteral("externaltools"), KConfig::NoGlobals, QStandardPaths::ApplicationsLocation);
153​ reset();
154​ slotSelectionChanged();
155​}
156​
157​KateExternalToolsConfigWidget::~KateExternalToolsConfigWidget()
158​{
159​ delete m_config;
160​}
161​
162​QString KateExternalToolsConfigWidget::name() const
163​{
164​ return i18n("External Tools");
165​}
166​
167​QString KateExternalToolsConfigWidget::fullName() const
168​{
169​ return i18n("External Tools");
170​}
171​
172​QIcon KateExternalToolsConfigWidget::icon() const
173​{
174​ return QIcon();
175​}
176​
177​void KateExternalToolsConfigWidget::reset()
178​{
179​ // m_tools.clear();
180​ lbTools->clear();
181​
182​ // load the files from a KConfig
183​ const QStringList tools = m_config->group("Global").readEntry("tools", QStringList());
184​
185​ for (int i = 0; i < tools.size(); ++i) {
186​ const QString& toolSection = tools[i];
187​ KConfigGroup cg(m_config, toolSection);
188​ KateExternalTool* t = new KateExternalTool();
189​ t->load(cg);
190​
191​ if (t->hasexec) // we only show tools that are also in the menu.
192​ new ToolItem(lbTools, t->icon.isEmpty() ? blankIcon() : SmallIcon(t->icon), t);
193​ else
194​ delete t;
195​ }
196​ m_changed = false;
197​}
198​
199​QPixmap KateExternalToolsConfigWidget::blankIcon()
200​{
201​ QPixmap pm(KIconLoader::SizeSmall, KIconLoader::SizeSmall);
202​ pm.fill();
203​ pm.setMask(pm.createHeuristicMask());
204​ return pm;
205​}
206​
207​void KateExternalToolsConfigWidget::apply()
208​{
209​ if (!m_changed)
210​ return;
211​ m_changed = false;
212​
213​ QStringList tools;
214​ for (int i = 0; i < lbTools->count(); i++) {
215​ const QString toolSection = QStringLiteral("Tool ") + QString::number(i);
216​ tools << toolSection;
217​
218​ KConfigGroup cg(m_config, toolSection);
219​ KateExternalTool* t = static_cast<ToolItem*>(lbTools->item(i))->tool;
220​ t->save(cg);
221​ }
222​
223​ m_config->group("Global").writeEntry("tools", tools);
224​
225​ m_config->sync();
226​ m_plugin->reload();
227​}
228​
229​void KateExternalToolsConfigWidget::slotSelectionChanged()
230​{
231​ // update button state
232​ bool hs = lbTools->currentItem() != nullptr;
233​ btnEdit->setEnabled(hs && dynamic_cast<ToolItem*>(lbTools->currentItem()));
234​ btnRemove->setEnabled(hs);
235​ btnMoveUp->setEnabled((lbTools->currentRow() > 0) && hs);
236​ btnMoveDown->setEnabled((lbTools->currentRow() < (int)lbTools->count() - 1) && hs);
237​}
238​
239​void KateExternalToolsConfigWidget::slotNew()
240​{
241​ // display a editor, and if it is OK'd, create a new tool and
242​ // create a listbox item for it
243​ KateExternalToolServiceEditor editor(nullptr, this);
244​
245​ if (editor.exec() == QDialog::Accepted) {
246​ KateExternalTool* t = new KateExternalTool();
247​ t->name = editor.ui->edtName->text();
248​ t->icon = editor.ui->btnIcon->icon();
249​ t->executable = editor.ui->edtExecutable->text();
250​ t->arguments = editor.ui->edtArgs->text();
251​ t->input = editor.ui->edtInput->toPlainText();
252​ t->workingDir = editor.ui->edtWorkingDir->text();
253​ t->mimetypes = editor.ui->edtMimeType->text().split(QRegularExpression(QStringLiteral("\\s*;\\s*")),
254​ QString::SkipEmptyParts);
255​ t->saveMode = static_cast<KateExternalTool::SaveMode>(editor.ui->cmbSave->currentIndex());
256​ t->includeStderr = editor.ui->chkIncludeStderr->isChecked();
257​
258​ // This is sticky, it does not change again, so that shortcuts sticks
loh.tarUnsubmitted
Not Done

{ }

loh.tar: { }
259​ // TODO check for dups
260​ t->actionName = QStringLiteral("externaltool_") + QString(t->name).remove(QRegExp(QStringLiteral("\\W+")));
261​
262​ new ToolItem(lbTools, t->icon.isEmpty() ? blankIcon() : SmallIcon(t->icon), t);
263​
264​ emit changed();
265​ m_changed = true;
266​ }
267​}
268​
269​void KateExternalToolsConfigWidget::slotRemove()
270​{
271​ // add the tool action name to a list of removed items,
272​ // remove the current listbox item
273​ if (lbTools->currentRow() > -1) {
274​ ToolItem* i = dynamic_cast<ToolItem*>(lbTools->currentItem());
275​ if (i)
276​ m_removed << i->tool->actionName;
277​
278​ delete lbTools->takeItem(lbTools->currentRow());
279​ emit changed();
280​ m_changed = true;
281​ }
282​}
283​
284​void KateExternalToolsConfigWidget::slotEdit()
285​{
286​ if (!dynamic_cast<ToolItem*>(lbTools->currentItem()))
287​ return;
288​ // show the item in an editor
289​ KateExternalTool* t = static_cast<ToolItem*>(lbTools->currentItem())->tool;
290​ KateExternalToolServiceEditor editor(t, this);
291​ editor.resize(m_config->group("Editor").readEntry("Size", QSize()));
292​ if (editor.exec() /*== KDialog::Ok*/) {
293​
294​ bool elementChanged = ((editor.ui->btnIcon->icon() != t->icon) || (editor.ui->edtName->text() != t->name));
295​
296​ t->name = editor.ui->edtName->text();
297​ t->icon = editor.ui->btnIcon->icon();
298​ t->executable = editor.ui->edtExecutable->text();
299​ t->arguments = editor.ui->edtArgs->text();
300​ t->input = editor.ui->edtInput->toPlainText();
301​ t->cmdname = editor.ui->edtCommand->text();
302​ t->workingDir = editor.ui->edtWorkingDir->text();
303​ t->mimetypes
304​ = editor.ui->edtMimeType->text().split(QRegExp(QStringLiteral("\\s*;\\s*")), QString::SkipEmptyParts);
305​ t->saveMode = static_cast<KateExternalTool::SaveMode>(editor.ui->cmbSave->currentIndex());
306​ t->includeStderr = editor.ui->chkIncludeStderr->isChecked();
307​
308​ // if the icon has changed or name changed, I have to renew the listbox item :S
309​ if (elementChanged) {
310​ int idx = lbTools->row(lbTools->currentItem());
311​ delete lbTools->takeItem(idx);
312​ lbTools->insertItem(idx, new ToolItem(nullptr, t->icon.isEmpty() ? blankIcon() : SmallIcon(t->icon), t));
313​ }
314​
315​ emit changed();
316​ m_changed = true;
317​ }
318​
319​ m_config->group("Editor").writeEntry("Size", editor.size());
320​ m_config->sync();
321​}
322​
323​void KateExternalToolsConfigWidget::slotMoveUp()
324​{
325​ // move the current item in the listbox upwards if possible
326​ QListWidgetItem* item = lbTools->currentItem();
327​ if (!item)
328​ return;
329​
330​ int idx = lbTools->row(item);
331​
loh.tarUnsubmitted
Not Done

search

loh.tar: search
332​ if (idx < 1)
333​ return;
334​
335​ if (dynamic_cast<ToolItem*>(item)) {
336​ KateExternalTool* tool = static_cast<ToolItem*>(item)->tool;
337​ delete lbTools->takeItem(idx);
338​ lbTools->insertItem(idx - 1,
339​ new ToolItem(nullptr, tool->icon.isEmpty() ? blankIcon() : SmallIcon(tool->icon), tool));
340​ }
341​
342​ lbTools->setCurrentRow(idx - 1);
343​ slotSelectionChanged();
344​ emit changed();
345​ m_changed = true;
346​}
347​
348​void KateExternalToolsConfigWidget::slotMoveDown()
349​{
350​ // move the current item in the listbox downwards if possible
351​ QListWidgetItem* item = lbTools->currentItem();
352​ if (!item)
353​ return;
354​
355​ int idx = lbTools->row(item);
356​
357​ if (idx > lbTools->count() - 1)
358​ return;
359​
360​ if (dynamic_cast<ToolItem*>(item)) {
361​ KateExternalTool* tool = static_cast<ToolItem*>(item)->tool;
362​ delete lbTools->takeItem(idx);
363​ lbTools->insertItem(idx + 1,
364​ new ToolItem(nullptr, tool->icon.isEmpty() ? blankIcon() : SmallIcon(tool->icon), tool));
365​ }
366​
367​ lbTools->setCurrentRow(idx + 1);
368​ slotSelectionChanged();
369​ emit changed();
370​ m_changed = true;
371​}
372​// END KateExternalToolsConfigWidget
373​
374​// kate: space-indent on; indent-width 4; replace-tabs on;