Differential D17971 Diff 53923 addons/externaltools/externaltoolsplugin.cpp

Changeset View

Standalone View

View Options

addons/externaltools/externaltoolsplugin.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​#include "externaltoolsplugin.h"
21​
22​#include "kateexternaltoolsview.h"
23​#include "kateexternaltool.h"
24​#include "kateexternaltoolscommand.h"
25​#include "katemacroexpander.h"
26​#include "katetoolrunner.h"
27​#include "kateexternaltoolsconfigwidget.h"
28​
29​#include <KTextEditor/Editor>
30​#include <KTextEditor/Document>
31​#include <KTextEditor/View>
32​#include <KActionCollection>
33​#include <KLocalizedString>
34​#include <QAction>
35​#include <kparts/part.h>
36​
37​#include <KAboutData>
38​#include <KAuthorized>
39​#include <KConfig>
40​#include <KConfigGroup>
41​#include <KPluginFactory>
42​#include <KXMLGUIFactory>
43​
44​K_PLUGIN_FACTORY_WITH_JSON(KateExternalToolsFactory, "externaltoolsplugin.json",
45​ registerPlugin<KateExternalToolsPlugin>();)
46​
47​KateExternalToolsPlugin::KateExternalToolsPlugin(QObject* parent, const QList<QVariant>&)
48​ : KTextEditor::Plugin(parent)
49​{
50​ reload();
51​}
52​
53​KateExternalToolsPlugin::~KateExternalToolsPlugin()
54​{
55​ delete m_command;
56​ m_command = nullptr;
57​}
58​
59​QObject* KateExternalToolsPlugin::createView(KTextEditor::MainWindow* mainWindow)
60​{
61​ KateExternalToolsPluginView* view = new KateExternalToolsPluginView(mainWindow, this);
62​ connect(this, &KateExternalToolsPlugin::externalToolsChanged, view, &KateExternalToolsPluginView::rebuildMenu);
63​ return view;
64​}
65​
66​void KateExternalToolsPlugin::reload()
67​{
68​ delete m_command;
69​ m_command = nullptr;
70​ m_commands.clear();
71​ qDeleteAll(m_tools);
72​ m_tools.clear();
73​
74​ KConfig _config(QStringLiteral("externaltools"), KConfig::NoGlobals, QStandardPaths::ApplicationsLocation);
75​ KConfigGroup config(&_config, "Global");
76​ const int toolCount = config.readEntry("tools", 0);
77​
78​ for (int i = 0; i < toolCount; ++i) {
79​ config = KConfigGroup(&_config, QStringLiteral("Tool %1").arg(i));
80​
81​ auto t = new KateExternalTool();
82​ t->load(config);
83​ m_tools.push_back(t);
84​
85​ // FIXME test for a command name first!
86​ if (t->hasexec && (!t->cmdname.isEmpty())) {
87​ m_commands.push_back(t->cmdname);
88​ }
89​ }
90​
91​ if (KAuthorized::authorizeAction(QStringLiteral("shell_access"))) {
92​ m_command = new KateExternalToolsCommand(this);
93​ }
94​
95​ Q_EMIT externalToolsChanged();
96​}
97​
98​QStringList KateExternalToolsPlugin::commands() const
99​{
100​ return m_commands;
101​}
102​
103​const KateExternalTool* KateExternalToolsPlugin::toolForCommand(const QString& cmd) const
104​{
105​ for (auto tool : m_tools) {
106​ if (tool->cmdname == cmd) {
107​ return tool;
108​ }
109​ }
110​ return nullptr;
111​}
112​
113​const QVector<KateExternalTool*> & KateExternalToolsPlugin::tools() const
114​{
115​ return m_tools;
116​}
117​
118​void KateExternalToolsPlugin::runTool(const KateExternalTool& tool, KTextEditor::View* view)
119​{
120​ // expand the macros in command if any,
121​ // and construct a command with an absolute path
122​ auto mw = view->mainWindow();
123​
124​ // save documents if requested
125​ if (tool.saveMode == KateExternalTool::SaveMode::CurrentDocument) {
126​ // only save if modified, to avoid unnecessary recompiles
127​ if (view->document()->isModified()) {
128​ view->document()->save();
129​ }
130​ } else if (tool.saveMode == KateExternalTool::SaveMode::AllDocuments) {
131​ foreach (KXMLGUIClient* client, mw->guiFactory()->clients()) {
132​ if (QAction* a = client->actionCollection()->action(QStringLiteral("file_save_all"))) {
133​ a->trigger();
134​ break;
135​ }
136​ }
137​ }
138​
139​ // copy tool
140​ std::unique_ptr<KateExternalTool> copy(new KateExternalTool(tool));
141​
142​ // clear previous toolview data
143​ auto pluginView = viewForMainWindow(mw);
144​ pluginView->clearToolView();
145​ pluginView->addToolStatus(i18n("Running external tool: %1", copy->name));
146​ pluginView->addToolStatus(i18n("- Executable: %1", copy->executable));
147​ pluginView->addToolStatus(i18n("- Arguments : %1", copy->arguments));
148​ pluginView->addToolStatus(i18n("- Input : %1", copy->input));
149​ pluginView->addToolStatus(QString());
150​
151​ // expand macros
152​ MacroExpander macroExpander(view);
153​ if (!macroExpander.expandMacrosShellQuote(copy->executable)) {
154​ pluginView->addToolStatus(i18n("Failed to expand executable: '%1'", copy->executable));
155​ pluginView->showToolView(ToolViewFocus::StatusTab);
156​ return;
157​ }
158​
159​ if (!macroExpander.expandMacrosShellQuote(copy->arguments)) {
160​ pluginView->addToolStatus(i18n("Failed to expand argument: %1", copy->arguments));
161​ pluginView->showToolView(ToolViewFocus::StatusTab);
162​ return;
163​ }
164​
165​ if (!macroExpander.expandMacrosShellQuote(copy->workingDir)) {
166​ pluginView->addToolStatus(i18n("Failed to expand working directory: %1", copy->workingDir));
167​ pluginView->showToolView(ToolViewFocus::StatusTab);
168​ return;
169​ }
170​
171​ if (!macroExpander.expandMacrosShellQuote(copy->input)) {
172​ pluginView->addToolStatus(i18n("Failed to expand input: %1", copy->input));
173​ pluginView->showToolView(ToolViewFocus::StatusTab);
174​ return;
175​ }
176​
177​ // Allocate runner on heap such that it lives as long as the child
178​ // process is running and does not block the main thread.
179​ auto runner = new KateToolRunner(std::move(copy), view, this);
180​
181​ // use QueuedConnection, since handleToolFinished deletes the runner
182​ connect(runner, &KateToolRunner::toolFinished, this, &KateExternalToolsPlugin::handleToolFinished, Qt::QueuedConnection);
183​ runner->run();
184​}
185​
186​void KateExternalToolsPlugin::handleToolFinished(KateToolRunner* runner, int exitCode, bool crashed)
187​{
188​ auto view = runner->view();
189​ if (view && !runner->outputData().isEmpty()) {
190​ switch (runner->tool()->outputMode) {
191​ case KateExternalTool::OutputMode::InsertAtCursor: {
192​ KTextEditor::Document::EditingTransaction transaction(view->document());
193​ view->removeSelection();
194​ view->insertText(runner->outputData());
195​ break;
196​ }
197​ case KateExternalTool::OutputMode::ReplaceSelectedText: {
198​ KTextEditor::Document::EditingTransaction transaction(view->document());
199​ view->removeSelectionText();
200​ view->insertText(runner->outputData());
201​ break;
202​ }
203​ case KateExternalTool::OutputMode::ReplaceCurrentDocument: {
204​ KTextEditor::Document::EditingTransaction transaction(view->document());
205​ view->document()->clear();
206​ view->insertText(runner->outputData());
207​ break;
208​ }
209​ case KateExternalTool::OutputMode::AppendToCurrentDocument: {
210​ view->document()->insertText(view->document()->documentEnd(), runner->outputData());
211​ break;
212​ }
213​ case KateExternalTool::OutputMode::InsertInNewDocument: {
214​ auto mainWindow = view->mainWindow();
215​ auto newView = mainWindow->openUrl({});
216​ newView->insertText(runner->outputData());
217​ mainWindow->activateView(newView->document());
218​ break;
219​ }
220​ default:
221​ break;
222​ }
223​ }
224​
225​ if (view && runner->tool()->reload) {
226​ // updates-enabled trick: avoid some flicker
227​ const bool wereUpdatesEnabled = view->updatesEnabled();
228​ view->setUpdatesEnabled(false);
229​ view->document()->documentReload();
230​ view->setUpdatesEnabled(wereUpdatesEnabled);
231​ }
232​
233​ KateExternalToolsPluginView* pluginView = runner->view() ? viewForMainWindow(runner->view()->mainWindow()) : nullptr;
loh.tarUnsubmitted
Not Done

runner->view() is your view

loh.tar: runner->view() is your view
234​ if (pluginView) {
235​ bool hasOutputInPane = false;
236​ if (runner->tool()->outputMode == KateExternalTool::OutputMode::DisplayInPane) {
237​ pluginView->setOutputData(runner->outputData());
238​ hasOutputInPane = !runner->outputData().isEmpty();
239​ }
240​
241​ if (!runner->errorData().isEmpty()) {
242​ pluginView->addToolStatus(i18n("Data written to stderr:"));
243​ pluginView->addToolStatus(runner->errorData());
244​ }
245​
246​ // empty line
247​ pluginView->addToolStatus(QString());
248​
249​ // print crash & exit code
250​ if (crashed) {
251​ pluginView->addToolStatus(i18n("Warning: External tool crashed."));
252​ }
253​ pluginView->addToolStatus(i18n("Finished with exit code: %1", exitCode));
254​
255​ if (crashed || exitCode != 0) {
256​ pluginView->showToolView(ToolViewFocus::StatusTab);
257​ } else if (hasOutputInPane) {
258​ pluginView->showToolView(ToolViewFocus::OutputTab);
259​ }
260​ }
261​
262​ delete runner;
loh.tarUnsubmitted
Not Done

Looks to me that in case of auto view == nullptr you could return on top of function and avoid all further tests

loh.tar: Looks to me that in case of auto view == nullptr you could return on top of function and avoid…
263​}
264​
265​int KateExternalToolsPlugin::configPages() const
266​{
267​ return 1;
268​}
269​
270​KTextEditor::ConfigPage* KateExternalToolsPlugin::configPage(int number, QWidget* parent)
271​{
272​ if (number == 0) {
273​ return new KateExternalToolsConfigWidget(parent, this);
274​ }
275​ return nullptr;
276​}
277​
278​void KateExternalToolsPlugin::registerPluginView(KateExternalToolsPluginView * view)
279​{
280​ Q_ASSERT(!m_views.contains(view));
281​ m_views.push_back(view);
282​}
283​
284​void KateExternalToolsPlugin::unregisterPluginView(KateExternalToolsPluginView * view)
285​{
286​ Q_ASSERT(m_views.contains(view));
287​ m_views.removeAll(view);
288​}
289​
290​KateExternalToolsPluginView* KateExternalToolsPlugin::viewForMainWindow(KTextEditor::MainWindow* mainWindow) const
291​{
292​ for (auto view : m_views) {
293​ if (view->mainWindow() == mainWindow) {
294​ return view;
295​ }
296​ }
297​ return nullptr;
298​}
299​
300​#include "externaltoolsplugin.moc"
301​
302​// kate: space-indent on; indent-width 4; replace-tabs on;