diff --git a/addons/externaltools/CMakeLists.txt b/addons/externaltools/CMakeLists.txt
index 72e71ef80..4ccf16311 100644
--- a/addons/externaltools/CMakeLists.txt
+++ b/addons/externaltools/CMakeLists.txt
@@ -1,31 +1,32 @@
 project(externaltoolsplugin)
 add_definitions(-DTRANSLATION_DOMAIN=\"externaltoolsplugin\")
 
 include_directories( ${CMAKE_CURRENT_BINARY_DIR} )
 
 set(externaltoolsplugin_PART_SRCS
     externaltoolsplugin.cpp
     externaltools.cpp
 )
 
 # resource for ui file and stuff
 qt5_add_resources(externaltoolsplugin_PART_SRCS plugin.qrc)
 
 set(externaltoolsplugin_PART_UI
     configwidget.ui
+    tooldialog.ui
 )
 ki18n_wrap_ui(externaltoolsplugin_PART_SRCS ${externaltoolsplugin_PART_UI} )
 add_library(externaltoolsplugin MODULE ${externaltoolsplugin_PART_SRCS})
 
 # we compile in the .desktop file
 kcoreaddons_desktop_to_json (externaltoolsplugin externaltoolsplugin.desktop)
 
 target_link_libraries(externaltoolsplugin
     KF5::CoreAddons
     KF5::IconThemes
     KF5::TextEditor
     KF5::I18n
 )
 
 ########### install files ###############
 install(TARGETS externaltoolsplugin DESTINATION ${PLUGIN_INSTALL_DIR}/ktexteditor )
diff --git a/addons/externaltools/externaltools.cpp b/addons/externaltools/externaltools.cpp
index 690c750dd..79ff238bb 100644
--- a/addons/externaltools/externaltools.cpp
+++ b/addons/externaltools/externaltools.cpp
@@ -1,820 +1,734 @@
 /*
    This file is part of the Kate text editor of the KDE project.
 
    This library is free software; you can redistribute it and/or
    modify it under the terms of the GNU Library General Public
    License version 2 as published by the Free Software Foundation.
 
    This library is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
    Library General Public License for more details.
 
    You should have received a copy of the GNU Library General Public License
    along with this library; see the file COPYING.LIB.  If not, write to
    the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
    Boston, MA 02110-1301, USA.
 
    ---
    Copyright (C) 2004, Anders Lund <anders@alweb.dk>
 */
 // TODO
 // Icons
 // Direct shortcut setting
 #include "externaltools.h"
 #include "externaltoolsplugin.h"
 #include <KTextEditor/Document>
 #include <KTextEditor/Editor>
 #include <KTextEditor/View>
 
 #include <KActionCollection>
 #include <KConfig>
 #include <KConfigGroup>
 #include <KIconButton>
 #include <KIconLoader>
 #include <KMessageBox>
 #include <KMimeTypeChooser>
 #include <KRun>
 #include <KSharedConfig>
 #include <KXMLGUIFactory>
 #include <KXmlGuiWindow>
 #include <QComboBox>
 #include <QLineEdit>
 #include <QListWidget>
 #include <QMenu>
 #include <QStandardPaths>
 
 #include <QBitmap>
 #include <QFile>
 #include <QGridLayout>
 #include <QLabel>
 #include <QObject>
 #include <QPushButton>
 #include <QRegExp>
 #include <QTextEdit>
 #include <QToolButton>
 
 #include <unistd.h>
 
 // BEGIN KateExternalTool
 KateExternalTool::KateExternalTool(const QString& name, const QString& command, const QString& icon,
                                    const QString& tryexec, const QStringList& mimetypes, const QString& acname,
                                    const QString& cmdname, int save)
     : name(name)
     , command(command)
     , icon(icon)
     , tryexec(tryexec)
     , mimetypes(mimetypes)
     , acname(acname)
     , cmdname(cmdname)
     , save(save)
 {
     // if ( ! tryexec.isEmpty() )
     hasexec = checkExec();
 }
 
 bool KateExternalTool::checkExec()
 {
     // if tryexec is empty, it is the first word of command
     if (tryexec.isEmpty())
         tryexec = command.section(QLatin1Char(' '), 0, 0, QString::SectionSkipEmpty);
 
     // NOTE this code is modified taken from kdesktopfile.cpp, from KDesktopFile::tryExec()
     if (!tryexec.isEmpty()) {
         m_exec = QStandardPaths::findExecutable(tryexec);
         return !m_exec.isEmpty();
     }
     return false;
 }
 
 bool KateExternalTool::valid(const QString& mt) const
 {
     return mimetypes.isEmpty() || mimetypes.contains(mt);
 }
 // END KateExternalTool
 
 // BEGIN KateExternalToolsCommand
 KateExternalToolsCommand::KateExternalToolsCommand(KateExternalToolsPlugin* plugin)
     : KTextEditor::Command({/* FIXME */})
     , m_plugin(plugin)
 {
     reload();
 }
 
 // FIXME
 // const QStringList& KateExternalToolsCommand::cmds()
 // {
 //     return m_list;
 // }
 
 void KateExternalToolsCommand::reload()
 {
     m_list.clear();
     m_map.clear();
     m_name.clear();
 
     KConfig _config(QStringLiteral("externaltools"), KConfig::NoGlobals, QStandardPaths::ApplicationsLocation);
     KConfigGroup config(&_config, "Global");
     const QStringList tools = config.readEntry("tools", QStringList());
 
     for (QStringList::const_iterator it = tools.begin(); it != tools.end(); ++it) {
         if (*it == QStringLiteral("---"))
             continue;
 
         config = KConfigGroup(&_config, *it);
 
         KateExternalTool t
             = KateExternalTool(config.readEntry(QStringLiteral("name"), ""), config.readEntry("command", ""),
                                config.readEntry(QStringLiteral("icon"), ""), config.readEntry("executable", ""),
                                config.readEntry(QStringLiteral("mimetypes"), QStringList()),
                                config.readEntry(QStringLiteral("acname"), ""), config.readEntry("cmdname", ""));
         // FIXME test for a command name first!
         if (t.hasexec && (!t.cmdname.isEmpty())) {
             m_list.append(QStringLiteral("exttool-") + t.cmdname);
             m_map.insert(QStringLiteral("exttool-") + t.cmdname, t.acname);
             m_name.insert(QStringLiteral("exttool-") + t.cmdname, t.name);
         }
     }
 }
 
 bool KateExternalToolsCommand::exec(KTextEditor::View* view, const QString& cmd, QString& msg,
                                     const KTextEditor::Range& range)
 {
     Q_UNUSED(msg)
     Q_UNUSED(range)
 
     auto wv = dynamic_cast<QWidget*>(view);
     if (!wv) {
         //   qDebug()<<"KateExternalToolsCommand::exec: Could not get view widget";
         return false;
     }
 
     //  qDebug()<<"cmd="<<cmd.trimmed();
     const QString actionName = m_map[cmd.trimmed()];
     if (actionName.isEmpty())
         return false;
     //  qDebug()<<"actionName is not empty:"<<actionName;
     /*  KateExternalToolsMenuAction *a =
         dynamic_cast<KateExternalToolsMenuAction*>(dmw->action("tools_external"));
       if (!a) return false;*/
     KateExternalToolsPluginView* extview = m_plugin->extView(wv->window());
     if (!extview)
         return false;
     if (!extview->externalTools)
         return false;
     //  qDebug()<<"trying to find action";
     QAction* a1 = extview->externalTools->actionCollection()->action(actionName);
     if (!a1)
         return false;
     //  qDebug()<<"activating action";
     a1->trigger();
     return true;
 }
 
 bool KateExternalToolsCommand::help(KTextEditor::View*, const QString&, QString&)
 {
     return false;
 }
 // END KateExternalToolsCommand
 
 // BEGIN KateExternalToolAction
 KateExternalToolAction::KateExternalToolAction(QObject* parent, KateExternalTool* t)
     : QAction(QIcon::fromTheme(t->icon), t->name, parent)
     , tool(t)
 {
     setText(t->name);
     if (!t->icon.isEmpty())
         setIcon(QIcon::fromTheme(t->icon));
 
     connect(this, SIGNAL(triggered(bool)), SLOT(slotRun()));
 }
 
 bool KateExternalToolAction::expandMacro(const QString& str, QStringList& ret)
 {
     KTextEditor::MainWindow* mw = qobject_cast<KTextEditor::MainWindow*>(parent()->parent());
     Q_ASSERT(mw);
 
     KTextEditor::View* view = mw->activeView();
     if (!view)
         return false;
 
     KTextEditor::Document* doc = view->document();
     QUrl url = doc->url();
 
     if (str == QStringLiteral("URL"))
         ret += url.url();
     else if (str == QStringLiteral("directory")) // directory of current doc
         ret += url.toString(QUrl::RemoveScheme | QUrl::RemoveFilename);
     else if (str == QStringLiteral("filename"))
         ret += url.fileName();
     else if (str == QStringLiteral("line")) // cursor line of current doc
         ret += QString::number(view->cursorPosition().line());
     else if (str == QStringLiteral("col")) // cursor col of current doc
         ret += QString::number(view->cursorPosition().column());
     else if (str == QStringLiteral("selection")) // selection of current doc if any
         ret += view->selectionText();
     else if (str == QStringLiteral("text")) // text of current doc
         ret += doc->text();
     else if (str == QStringLiteral("URLs")) {
         foreach (KTextEditor::Document* it, KTextEditor::Editor::instance()->application()->documents())
             if (!it->url().isEmpty())
                 ret += it->url().url();
     } else
         return false;
 
     return true;
 }
 
 KateExternalToolAction::~KateExternalToolAction()
 {
     delete (tool);
 }
 
 void KateExternalToolAction::slotRun()
 {
     // expand the macros in command if any,
     // and construct a command with an absolute path
     QString cmd = tool->command;
 
     auto mw = qobject_cast<KTextEditor::MainWindow*>(parent()->parent());
     if (!expandMacrosShellQuote(cmd)) {
         KMessageBox::sorry(mw->window(), i18n("Failed to expand the command '%1'.", cmd), i18n("Kate External Tools"));
         return;
     }
     qDebug() << "externaltools: Running command: " << cmd;
 
     // save documents if requested
     if (tool->save == 1)
         mw->activeView()->document()->save();
     else if (tool->save == 2) {
         foreach (KXMLGUIClient* client, mw->guiFactory()->clients()) {
             if (QAction* a = client->actionCollection()->action(QStringLiteral("file_save_all"))) {
                 a->trigger();
                 break;
             }
         }
     }
 
     KRun::runCommand(cmd, tool->tryexec, tool->icon, mw->window());
 }
 // END KateExternalToolAction
 
 // BEGIN KateExternalToolsMenuAction
 KateExternalToolsMenuAction::KateExternalToolsMenuAction(const QString& text, KActionCollection* collection,
                                                          QObject* parent, KTextEditor::MainWindow* mw)
     : KActionMenu(text, parent)
     , mainwindow(mw)
 {
 
     m_actionCollection = collection;
 
     // connect to view changed...
     connect(mw, &KTextEditor::MainWindow::viewChanged, this, &KateExternalToolsMenuAction::slotViewChanged);
 
     reload();
 }
 
 KateExternalToolsMenuAction::~KateExternalToolsMenuAction()
 {
     // kDebug() << "deleted KateExternalToolsMenuAction";
 }
 
 void KateExternalToolsMenuAction::reload()
 {
     bool needs_readd = (m_actionCollection->takeAction(this) != nullptr);
     m_actionCollection->clear();
     if (needs_readd)
         m_actionCollection->addAction(QStringLiteral("tools_external"), this);
     menu()->clear();
 
     // load all the tools, and create a action for each of them
     KSharedConfig::Ptr pConfig = KSharedConfig::openConfig(QStringLiteral("externaltools"), KConfig::NoGlobals,
                                                            QStandardPaths::ApplicationsLocation);
     KConfigGroup config(pConfig, "Global");
     QStringList tools = config.readEntry("tools", QStringList());
 
     // if there are tools that are present but not explicitly removed,
     // add them to the end of the list
     pConfig->setReadDefaults(true);
     QStringList dtools = config.readEntry("tools", QStringList());
     int gver = config.readEntry("version", 1);
     pConfig->setReadDefaults(false);
 
     int ver = config.readEntry("version", 0);
     if (ver <= gver) {
         QStringList removed = config.readEntry("removed", QStringList());
         bool sepadded = false;
         for (QStringList::iterator itg = dtools.begin(); itg != dtools.end(); ++itg) {
             if (!tools.contains(*itg) && !removed.contains(*itg)) {
                 if (!sepadded) {
                     tools << QStringLiteral("---");
                     sepadded = true;
                 }
                 tools << *itg;
             }
         }
 
         config.writeEntry("tools", tools);
         config.sync();
         config.writeEntry("version", gver);
     }
 
     for (QStringList::const_iterator it = tools.constBegin(); it != tools.constEnd(); ++it) {
         if (*it == QStringLiteral("---")) {
             menu()->addSeparator();
             // a separator
             continue;
         }
 
         config = KConfigGroup(pConfig, *it);
 
         KateExternalTool* t = new KateExternalTool(
             config.readEntry("name", ""), config.readEntry("command", ""), config.readEntry("icon", ""),
             config.readEntry("executable", ""), config.readEntry("mimetypes", QStringList()),
             config.readEntry("acname", ""), config.readEntry("cmdname", ""), config.readEntry("save", 0));
 
         if (t->hasexec) {
             QAction* a = new KateExternalToolAction(this, t);
             m_actionCollection->addAction(t->acname, a);
             addAction(a);
         } else
             delete t;
     }
 
     config = KConfigGroup(pConfig, "Shortcuts");
     m_actionCollection->readSettings(&config);
     slotViewChanged(mainwindow->activeView());
 }
 
 void KateExternalToolsMenuAction::slotViewChanged(KTextEditor::View* view)
 {
     // no active view, oh oh
     if (!view) {
         return;
     }
 
     // try to enable/disable to match current mime type
     KTextEditor::Document* doc = view->document();
     if (doc) {
         const QString mimeType = doc->mimeType();
         foreach (QAction* kaction, m_actionCollection->actions()) {
             KateExternalToolAction* action = dynamic_cast<KateExternalToolAction*>(kaction);
             if (action) {
                 const QStringList l = action->tool->mimetypes;
                 const bool b = (!l.count() || l.contains(mimeType));
                 action->setEnabled(b);
             }
         }
     }
 }
 // END KateExternalToolsMenuAction
 
 // BEGIN ToolItem
 /**
  * This is a QListBoxItem, that has a KateExternalTool. The text is the Name
  * of the tool.
  */
 class ToolItem : public QListWidgetItem
 {
 public:
     ToolItem(QListWidget* lb, const QPixmap& icon, KateExternalTool* tool)
         : QListWidgetItem(icon, tool->name, lb)
         , tool(tool)
     {
     }
 
     ~ToolItem() {}
 
     KateExternalTool* tool;
 };
 // END ToolItem
 
 // BEGIN KateExternalToolServiceEditor
 KateExternalToolServiceEditor::KateExternalToolServiceEditor(KateExternalTool* tool, QWidget* parent)
     : QDialog(parent)
     , tool(tool)
 {
     setWindowTitle(i18n("Edit External Tool"));
 
-    auto vbox = new QVBoxLayout(this);
-    auto buttonBox = new QDialogButtonBox(QDialogButtonBox::Ok | QDialogButtonBox::Cancel);
-    connect(buttonBox, &QDialogButtonBox::accepted, this, &KateExternalToolServiceEditor::slotOKClicked);
-    connect(buttonBox, &QDialogButtonBox::rejected, this, &QDialog::reject);
-
-    // create a entry for each property
-    // fill in the values from the service if available
-    auto w = new QWidget(this);
-    vbox->addWidget(w);
-    vbox->addWidget(buttonBox);
-
-    auto lo = new QGridLayout(w);
-    lo->setContentsMargins(0, 0, 0, 0);
-
-    leName = new QLineEdit(w);
-    lo->addWidget(leName, 1, 2);
-    auto l = new QLabel(w);
-    l->setBuddy(leName);
-    l->setText(i18n("&Label:"));
-    l->setAlignment(l->alignment() | Qt::AlignRight);
-    lo->addWidget(l, 1, 1);
+    ui = new Ui::ToolDialog();
+    ui->setupUi(this);
+
+    connect(ui->buttonBox, &QDialogButtonBox::accepted, this, &KateExternalToolServiceEditor::slotOKClicked);
+    connect(ui->buttonBox, &QDialogButtonBox::rejected, this, &QDialog::reject);
+
     if (tool)
-        leName->setText(tool->name);
-    leName->setWhatsThis(i18n("The name will be displayed in the 'Tools->External Tools' menu"));
+        ui->edtName->setText(tool->name);
 
-    btnIcon = new KIconButton(w);
-    btnIcon->setIconSize(KIconLoader::SizeSmall);
-    lo->addWidget(btnIcon, 1, 3);
     if (tool && !tool->icon.isEmpty())
-        btnIcon->setIcon(tool->icon);
-
-    teCommand = new QTextEdit(w);
-    lo->addWidget(teCommand, 2, 2, 1, 2);
-    l = new QLabel(w);
-    l->setBuddy(teCommand);
-    l->setText(i18n("S&cript:"));
-    l->setAlignment(Qt::AlignTop | Qt::AlignRight);
-    lo->addWidget(l, 2, 1);
+        ui->btnIcon->setIcon(tool->icon);
+
     if (tool)
-        teCommand->setText(tool->command);
-    teCommand->setWhatsThis(i18n("<p>The script to execute to invoke the tool. The script is passed "
-                                 "to /bin/sh for execution. The following macros "
-                                 "will be expanded:</p>"
-                                 "<ul><li><code>%URL</code> - the URL of the current document.</li>"
-                                 "<li><code>%URLs</code> - a list of the URLs of all open documents.</li>"
-                                 "<li><code>%directory</code> - the URL of the directory containing "
-                                 "the current document.</li>"
-                                 "<li><code>%filename</code> - the filename of the current document.</li>"
-                                 "<li><code>%line</code> - the current line of the text cursor in the "
-                                 "current view.</li>"
-                                 "<li><code>%column</code> - the column of the text cursor in the "
-                                 "current view.</li>"
-                                 "<li><code>%selection</code> - the selected text in the current view.</li>"
-                                 "<li><code>%text</code> - the text of the current document.</li></ul>"));
-
-    leExecutable = new QLineEdit(w);
-    lo->addWidget(leExecutable, 3, 2, 1, 2);
-    l = new QLabel(w);
-    l->setBuddy(leExecutable);
-    l->setText(i18n("&Executable:"));
-    l->setAlignment(l->alignment() | Qt::AlignRight);
-    lo->addWidget(l, 3, 1);
+        ui->edtInput->setText(tool->command);
+
     if (tool)
-        leExecutable->setText(tool->tryexec);
-    leExecutable->setWhatsThis(i18n("The executable used by the command. This is used to check if a tool "
-                                    "should be displayed; if not set, the first word of <em>command</em> "
-                                    "will be used."));
-
-    leMimetypes = new QLineEdit(w);
-    lo->addWidget(leMimetypes, 4, 2);
-    l = new QLabel(w);
-    l->setBuddy(leMimetypes);
-    l->setText(i18n("&Mime types:"));
-    l->setAlignment(l->alignment() | Qt::AlignRight);
-    lo->addWidget(l, 4, 1);
+        ui->edtExecutable->setText(tool->tryexec);
     if (tool)
-        leMimetypes->setText(tool->mimetypes.join(QStringLiteral("; ")));
-    leMimetypes->setWhatsThis(i18n("A semicolon-separated list of mime types for which this tool should "
-                                   "be available; if this is left empty, the tool is always available. "
-                                   "To choose from known mimetypes, press the button on the right."));
-
-    auto btnMimetype = new QToolButton(w);
-    lo->addWidget(btnMimetype, 4, 3);
-    btnMimetype->setIcon(QIcon::fromTheme(QStringLiteral("tools-wizard")));
-    connect(btnMimetype, &QToolButton::clicked, this, &KateExternalToolServiceEditor::showMTDlg);
-    btnMimetype->setWhatsThis(i18n("Click for a dialog that can help you create a list of mimetypes."));
-
-    cmbSave = new QComboBox(w);
-    lo->addWidget(cmbSave, 5, 2, 1, 2);
-    l = new QLabel(w);
-    l->setBuddy(cmbSave);
-    l->setText(i18n("&Save:"));
-    l->setAlignment(l->alignment() | Qt::AlignRight);
-    lo->addWidget(l, 5, 1);
-    cmbSave->addItems({ i18n("None"), i18n("Current Document"), i18n("All Documents") });
+        ui->edtMimeType->setText(tool->mimetypes.join(QStringLiteral("; ")));
+    connect(ui->btnMimeType, &QToolButton::clicked, this, &KateExternalToolServiceEditor::showMTDlg);
+
     if (tool)
-        cmbSave->setCurrentIndex(tool->save);
-    cmbSave->setWhatsThis(i18n("You can choose to save the current or all [modified] documents prior to "
-                               "running the command. This is helpful if you want to pass URLs to "
-                               "an application like, for example, an FTP client."));
-
-    leCmdLine = new QLineEdit(w);
-    lo->addWidget(leCmdLine, 6, 2, 1, 2);
-    l = new QLabel(i18n("&Command line name:"), w);
-    l->setBuddy(leCmdLine);
-    l->setAlignment(l->alignment() | Qt::AlignRight);
-    lo->addWidget(l, 6, 1);
+        ui->cmbSave->setCurrentIndex(tool->save);
+
     if (tool)
-        leCmdLine->setText(tool->cmdname);
-    leCmdLine->setWhatsThis(i18n("If you specify a name here, you can invoke the command from the view "
-                                 "command line with exttool-the_name_you_specified_here. "
-                                 "Please do not use spaces or tabs in the name."));
+        ui->edtCommand->setText(tool->cmdname);
 }
 
 void KateExternalToolServiceEditor::slotOKClicked()
 {
-    if (leName->text().isEmpty() || teCommand->document()->isEmpty()) {
+    if (ui->edtName->text().isEmpty() || ui->edtInput->document()->isEmpty()) {
         QMessageBox::information(this, i18n("External Tool"), i18n("You must specify at least a name and a command"));
         return;
     }
     accept();
 }
 
 void KateExternalToolServiceEditor::showMTDlg()
 {
     QString text = i18n("Select the MimeTypes for which to enable this tool.");
-    QStringList list = leMimetypes->text().split(QRegExp(QStringLiteral("\\s*;\\s*")), QString::SkipEmptyParts);
+    QStringList list = ui->edtMimeType->text().split(QRegExp(QStringLiteral("\\s*;\\s*")), QString::SkipEmptyParts);
     KMimeTypeChooserDialog d(i18n("Select Mime Types"), text, list, QStringLiteral("text"), this);
     if (d.exec() == QDialog::Accepted) {
-        leMimetypes->setText(d.chooser()->mimeTypes().join(QStringLiteral(";")));
+        ui->edtMimeType->setText(d.chooser()->mimeTypes().join(QStringLiteral(";")));
     }
 }
 // END KateExternalToolServiceEditor
 
 // BEGIN KateExternalToolsConfigWidget
 KateExternalToolsConfigWidget::KateExternalToolsConfigWidget(QWidget* parent, KateExternalToolsPlugin* plugin)
     : KTextEditor::ConfigPage(parent)
     , m_changed(false)
     , m_plugin(plugin)
 {
     setupUi(this);
 
     btnMoveUp->setIcon(QIcon::fromTheme(QStringLiteral("go-up")));
     btnMoveDown->setIcon(QIcon::fromTheme(QStringLiteral("go-down")));
 
     connect(lbTools, &QListWidget::itemSelectionChanged, this, &KateExternalToolsConfigWidget::slotSelectionChanged);
     connect(lbTools, &QListWidget::itemDoubleClicked, this, &KateExternalToolsConfigWidget::slotEdit);
     connect(btnNew, &QPushButton::clicked, this, &KateExternalToolsConfigWidget::slotNew);
     connect(btnRemove, &QPushButton::clicked, this, &KateExternalToolsConfigWidget::slotRemove);
     connect(btnEdit, &QPushButton::clicked, this, &KateExternalToolsConfigWidget::slotEdit);
     connect(btnSeparator, &QPushButton::clicked, this, &KateExternalToolsConfigWidget::slotInsertSeparator);
     connect(btnMoveUp, &QPushButton::clicked, this, &KateExternalToolsConfigWidget::slotMoveUp);
     connect(btnMoveDown, &QPushButton::clicked, this, &KateExternalToolsConfigWidget::slotMoveDown);
 
     config = new KConfig(QStringLiteral("externaltools"), KConfig::NoGlobals, QStandardPaths::ApplicationsLocation);
     reset();
     slotSelectionChanged();
 }
 
 KateExternalToolsConfigWidget::~KateExternalToolsConfigWidget()
 {
     delete config;
 }
 
 QString KateExternalToolsConfigWidget::name() const
 {
     return i18n("External Tools");
 }
 
 QString KateExternalToolsConfigWidget::fullName() const
 {
     return i18n("External Tools");
 }
 
 QIcon KateExternalToolsConfigWidget::icon() const
 {
     return QIcon();
 }
 
 void KateExternalToolsConfigWidget::reset()
 {
     // m_tools.clear();
     lbTools->clear();
 
     // load the files from a KConfig
     const QStringList tools = config->group("Global").readEntry("tools", QStringList());
 
     for (QStringList::const_iterator it = tools.begin(); it != tools.end(); ++it) {
         if (*it == QStringLiteral("---")) {
             new QListWidgetItem(QStringLiteral("---"), lbTools);
         } else {
             KConfigGroup cg(config, *it);
 
             KateExternalTool* t
                 = new KateExternalTool(cg.readEntry("name", ""), cg.readEntry("command", ""), cg.readEntry("icon", ""),
                                        cg.readEntry("executable", ""), cg.readEntry("mimetypes", QStringList()),
                                        cg.readEntry("acname"), cg.readEntry("cmdname"), cg.readEntry("save", 0));
 
             if (t->hasexec) // we only show tools that are also in the menu.
                 new ToolItem(lbTools, t->icon.isEmpty() ? blankIcon() : SmallIcon(t->icon), t);
             else
                 delete t;
         }
     }
     m_changed = false;
 }
 
 QPixmap KateExternalToolsConfigWidget::blankIcon()
 {
     QPixmap pm(KIconLoader::SizeSmall, KIconLoader::SizeSmall);
     pm.fill();
     pm.setMask(pm.createHeuristicMask());
     return pm;
 }
 
 void KateExternalToolsConfigWidget::apply()
 {
     if (!m_changed)
         return;
     m_changed = false;
 
     // save a new list
     // save each item
     QStringList tools;
     for (int i = 0; i < lbTools->count(); i++) {
         if (lbTools->item(i)->text() == QStringLiteral("---")) {
             tools << QStringLiteral("---");
             continue;
         }
         KateExternalTool* t = static_cast<ToolItem*>(lbTools->item(i))->tool;
         //     qDebug()<<"adding tool: "<<t->name;
         tools << t->acname;
 
         KConfigGroup cg(config, t->acname);
 
         cg.writeEntry("name", t->name);
         cg.writeEntry("command", t->command);
         cg.writeEntry("icon", t->icon);
         cg.writeEntry("executable", t->tryexec);
         cg.writeEntry("mimetypes", t->mimetypes);
         cg.writeEntry("acname", t->acname);
         cg.writeEntry("cmdname", t->cmdname);
         cg.writeEntry("save", t->save);
     }
 
     config->group("Global").writeEntry("tools", tools);
 
     // if any tools was removed, try to delete their groups, and
     // add the group names to the list of removed items.
     if (m_removed.count()) {
         for (QStringList::iterator it = m_removed.begin(); it != m_removed.end(); ++it) {
             if (config->hasGroup(*it))
                 config->deleteGroup(*it);
         }
         QStringList removed = config->group("Global").readEntry("removed", QStringList());
         removed += m_removed;
 
         // clean up the list of removed items, so that it does not contain
         // non-existing groups (we can't remove groups from a non-owned global file).
         config->sync();
         QStringList::iterator it1 = removed.begin();
         while (it1 != removed.end()) {
             if (!config->hasGroup(*it1))
                 it1 = removed.erase(it1);
             else
                 ++it1;
         }
         config->group("Global").writeEntry("removed", removed);
     }
 
     config->sync();
     m_plugin->reload();
 }
 
 void KateExternalToolsConfigWidget::slotSelectionChanged()
 {
     // update button state
     bool hs = lbTools->currentItem() != nullptr;
     btnEdit->setEnabled(hs && dynamic_cast<ToolItem*>(lbTools->currentItem()));
     btnRemove->setEnabled(hs);
     btnMoveUp->setEnabled((lbTools->currentRow() > 0) && hs);
     btnMoveDown->setEnabled((lbTools->currentRow() < (int)lbTools->count() - 1) && hs);
 }
 
 void KateExternalToolsConfigWidget::slotNew()
 {
     // display a editor, and if it is OK'd, create a new tool and
     // create a listbox item for it
     KateExternalToolServiceEditor editor(nullptr, this);
 
-    if (editor.exec()) {
+    if (editor.exec() == QDialog::Accepted) {
         KateExternalTool* t = new KateExternalTool(
-            editor.leName->text(), editor.teCommand->toPlainText(), editor.btnIcon->icon(), editor.leExecutable->text(),
-            editor.leMimetypes->text().split(QRegExp(QStringLiteral("\\s*;\\s*")), QString::SkipEmptyParts));
+            editor.ui->edtName->text(), editor.ui->edtInput->toPlainText(), editor.ui->btnIcon->icon(), editor.ui->edtExecutable->text(),
+            editor.ui->edtMimeType->text().split(QRegExp(QStringLiteral("\\s*;\\s*")), QString::SkipEmptyParts));
 
         // This is sticky, it does not change again, so that shortcuts sticks
         // TODO check for dups
         t->acname = QStringLiteral("externaltool_") + QString(t->name).remove(QRegExp(QStringLiteral("\\W+")));
 
         new ToolItem(lbTools, t->icon.isEmpty() ? blankIcon() : SmallIcon(t->icon), t);
 
         emit changed();
         m_changed = true;
     }
 }
 
 void KateExternalToolsConfigWidget::slotRemove()
 {
     // add the tool action name to a list of removed items,
     // remove the current listbox item
     if (lbTools->currentRow() > -1) {
         ToolItem* i = dynamic_cast<ToolItem*>(lbTools->currentItem());
         if (i)
             m_removed << i->tool->acname;
 
         delete lbTools->takeItem(lbTools->currentRow());
         emit changed();
         m_changed = true;
     }
 }
 
 void KateExternalToolsConfigWidget::slotEdit()
 {
     if (!dynamic_cast<ToolItem*>(lbTools->currentItem()))
         return;
     // show the item in an editor
     KateExternalTool* t = static_cast<ToolItem*>(lbTools->currentItem())->tool;
     KateExternalToolServiceEditor editor(t, this);
     editor.resize(config->group("Editor").readEntry("Size", QSize()));
     if (editor.exec() /*== KDialog::Ok*/) {
 
-        bool elementChanged = ((editor.btnIcon->icon() != t->icon) || (editor.leName->text() != t->name));
+        bool elementChanged = ((editor.ui->btnIcon->icon() != t->icon) || (editor.ui->edtName->text() != t->name));
 
-        t->name = editor.leName->text();
-        t->cmdname = editor.leCmdLine->text();
-        t->command = editor.teCommand->toPlainText();
-        t->icon = editor.btnIcon->icon();
-        t->tryexec = editor.leExecutable->text();
-        t->mimetypes = editor.leMimetypes->text().split(QRegExp(QStringLiteral("\\s*;\\s*")), QString::SkipEmptyParts);
-        t->save = editor.cmbSave->currentIndex();
+        t->name = editor.ui->edtName->text();
+        t->cmdname = editor.ui->edtCommand->text();
+        t->command = editor.ui->edtInput->toPlainText();
+        t->icon = editor.ui->btnIcon->icon();
+        t->tryexec = editor.ui->edtExecutable->text();
+        t->mimetypes = editor.ui->edtMimeType->text().split(QRegExp(QStringLiteral("\\s*;\\s*")), QString::SkipEmptyParts);
+        t->save = editor.ui->cmbSave->currentIndex();
 
         // if the icon has changed or name changed, I have to renew the listbox item :S
         if (elementChanged) {
             int idx = lbTools->row(lbTools->currentItem());
             delete lbTools->takeItem(idx);
             lbTools->insertItem(idx, new ToolItem(nullptr, t->icon.isEmpty() ? blankIcon() : SmallIcon(t->icon), t));
         }
 
         emit changed();
         m_changed = true;
     }
 
     config->group("Editor").writeEntry("Size", editor.size());
     config->sync();
 }
 
 void KateExternalToolsConfigWidget::slotInsertSeparator()
 {
     lbTools->insertItem(lbTools->currentRow() + 1, QStringLiteral("---"));
     emit changed();
     m_changed = true;
 }
 
 void KateExternalToolsConfigWidget::slotMoveUp()
 {
     // move the current item in the listbox upwards if possible
     QListWidgetItem* item = lbTools->currentItem();
     if (!item)
         return;
 
     int idx = lbTools->row(item);
 
     if (idx < 1)
         return;
 
     if (dynamic_cast<ToolItem*>(item)) {
         KateExternalTool* tool = static_cast<ToolItem*>(item)->tool;
         delete lbTools->takeItem(idx);
         lbTools->insertItem(idx - 1,
                             new ToolItem(nullptr, tool->icon.isEmpty() ? blankIcon() : SmallIcon(tool->icon), tool));
     } else // a separator!
     {
         delete lbTools->takeItem(idx);
         lbTools->insertItem(idx - 1, new QListWidgetItem(QStringLiteral("---")));
     }
 
     lbTools->setCurrentRow(idx - 1);
     slotSelectionChanged();
     emit changed();
     m_changed = true;
 }
 
 void KateExternalToolsConfigWidget::slotMoveDown()
 {
     // move the current item in the listbox downwards if possible
     QListWidgetItem* item = lbTools->currentItem();
     if (!item)
         return;
 
     int idx = lbTools->row(item);
 
     if (idx > lbTools->count() - 1)
         return;
 
     if (dynamic_cast<ToolItem*>(item)) {
         KateExternalTool* tool = static_cast<ToolItem*>(item)->tool;
         delete lbTools->takeItem(idx);
         lbTools->insertItem(idx + 1,
                             new ToolItem(nullptr, tool->icon.isEmpty() ? blankIcon() : SmallIcon(tool->icon), tool));
     } else // a separator!
     {
         delete lbTools->takeItem(idx);
         lbTools->insertItem(idx + 1, new QListWidgetItem(QStringLiteral("---")));
     }
 
     lbTools->setCurrentRow(idx + 1);
     slotSelectionChanged();
     emit changed();
     m_changed = true;
 }
 // END KateExternalToolsConfigWidget
 // kate: space-indent on; indent-width 4; replace-tabs on;
diff --git a/addons/externaltools/externaltools.h b/addons/externaltools/externaltools.h
index f762990e9..cf8e6166b 100644
--- a/addons/externaltools/externaltools.h
+++ b/addons/externaltools/externaltools.h
@@ -1,247 +1,246 @@
 /*
    This file is part of the Kate text editor of the KDE project.
    It describes a "external tools" action for kate and provides a dialog
    page to configure that.
 
    This library is free software; you can redistribute it and/or
    modify it under the terms of the GNU Library General Public
    License version 2 as published by the Free Software Foundation.
 
    This library is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
    Library General Public License for more details.
 
    You should have received a copy of the GNU Library General Public License
    along with this library; see the file COPYING.LIB.  If not, write to
    the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
    Boston, MA 02110-1301, USA.
 
    ---
    Copyright (C) 2004, Anders Lund <anders@alweb.dk>
 */
 
 #ifndef KTEXTEDITOR_EXTERNALTOOLS_H
 #define KTEXTEDITOR_EXTERNALTOOLS_H
 
 #include "ui_configwidget.h"
+#include "ui_tooldialog.h"
 
 #include <KTextEditor/Application>
 #include <KTextEditor/Command>
 #include <KTextEditor/ConfigPage>
 #include <KTextEditor/MainWindow>
 #include <KTextEditor/Plugin>
 
 #include <KActionMenu>
 #include <KMacroExpander>
 #include <QDialog>
 
 #include <QHash>
 #include <QPixmap>
 
 class KateExternalToolsPlugin;
 
 /**
  * The external tools action
  * This action creates a menu, in which each item will launch a process
  * with the provided arguments, which may include the following macros:
  * - %URLS: the URLs of all open documents.
  * - %URL: The URL of the active document.
  * - %filedir: The directory of the current document, if that is a local file.
  * - %selection: The selection of the active document.
  * - %text: The text of the active document.
  * - %line: The line number of the cursor in the active view.
  * - %column: The column of the cursor in the active view.
  *
  * Each item has the following properties:
  * - Name: The friendly text for the menu
  * - Exec: The command to execute, including arguments.
  * - TryExec: the name of the executable, if not available, the
  *       item will not be displayed.
  * - MimeTypes: An optional list of mimetypes. The item will be disabled or
  *       hidden if the current file is not of one of the indicated types.
  *
  */
 class KateExternalToolsMenuAction : public KActionMenu
 {
     friend class KateExternalToolAction;
 
     Q_OBJECT
 public:
     KateExternalToolsMenuAction(const QString& text, class KActionCollection* collection, QObject* parent,
                                 class KTextEditor::MainWindow* mw = nullptr);
     virtual ~KateExternalToolsMenuAction();
 
     /**
      * This will load all the confiured services.
      */
     void reload();
 
     class KActionCollection* actionCollection() { return m_actionCollection; }
 
 private Q_SLOTS:
     void slotViewChanged(KTextEditor::View* view);
 
 private:
     class KActionCollection* m_actionCollection;
     KTextEditor::MainWindow* mainwindow; // for the actions to access view/doc managers
 };
 
 /**
  * This Action contains a KateExternalTool
  */
 class KateExternalToolAction : public QAction, public KWordMacroExpander
 {
     Q_OBJECT
 public:
     KateExternalToolAction(QObject* parent, class KateExternalTool* t);
     ~KateExternalToolAction();
 
 protected:
     bool expandMacro(const QString& str, QStringList& ret) override;
 
 private Q_SLOTS:
     void slotRun();
 
 public:
     class KateExternalTool* tool;
 };
 
 /**
  * This class defines a single external tool.
  */
 class KateExternalTool
 {
 public:
     explicit KateExternalTool(const QString& name = QString(), const QString& command = QString(),
                               const QString& icon = QString(), const QString& tryexec = QString(),
                               const QStringList& mimetypes = QStringList(), const QString& acname = QString(),
                               const QString& cmdname = QString(), int save = 0);
     ~KateExternalTool() {}
 
     QString name; ///< The name used in the menu.
     QString command; ///< The command to execute.
     QString icon; ///< the icon to use in the menu.
     QString tryexec; ///< The name or path of the executable.
     QStringList mimetypes; ///< Optional list of mimetypes for which this action is valid.
     bool hasexec; ///< This is set by the constructor by calling checkExec(), if a
                   ///< value is present.
     QString acname; ///< The name for the action. This is generated first time the
                     ///< action is is created.
     QString cmdname; ///< The name for the commandline.
     int save; ///< We can save documents prior to activating the tool command: 0 =
               ///< nothing, 1 = current document, 2 = all documents.
 
     /**
      * @return true if mimetypes is empty, or the @p mimetype matches.
      */
     bool valid(const QString& mimetype) const;
     /**
      * @return true if "tryexec" exists and has the executable bit set, or is
      * empty.
      * This is run at least once, and the tool is disabled if it fails.
      */
     bool checkExec();
 
 private:
     QString m_exec; ///< The fully qualified path of the executable.
 };
 
 /**
  * The config widget.
  * The config widget allows the user to view a list of services of the type
  * "Kate/ExternalTool" and add, remove or edit them.
  */
 class KateExternalToolsConfigWidget : public KTextEditor::ConfigPage, public Ui::ExternalToolsConfigWidget
 {
     Q_OBJECT
 public:
     KateExternalToolsConfigWidget(QWidget* parent, KateExternalToolsPlugin* plugin);
     virtual ~KateExternalToolsConfigWidget();
 
     QString name() const override;
     QString fullName() const override;
     QIcon icon() const override;
 
 public Q_SLOTS:
     void apply() override;
     void reset() override;
     void defaults() override { reset(); } // double sigh
 
 private Q_SLOTS:
     void slotNew();
     void slotEdit();
     void slotRemove();
     void slotInsertSeparator();
 
     void slotMoveUp();
     void slotMoveDown();
 
     void slotSelectionChanged();
 
 private:
     QPixmap blankIcon();
 
     QStringList m_removed;
 
     class KConfig* config;
 
     bool m_changed;
     KateExternalToolsPlugin* m_plugin;
 };
 
 /**
  * A Singleton class for invoking external tools with the view command line
  */
 class KateExternalToolsCommand : public KTextEditor::Command
 {
 public:
     KateExternalToolsCommand(KateExternalToolsPlugin* plugin);
     virtual ~KateExternalToolsCommand() {}
     void reload();
 
 public:
     //     const QStringList& cmds() override; // FIXME
     bool exec(KTextEditor::View* view, const QString& cmd, QString& msg,
               const KTextEditor::Range& range = KTextEditor::Range::invalid()) override;
     bool help(KTextEditor::View* view, const QString& cmd, QString& msg) override;
 
 private:
     QStringList m_list;
     QHash<QString, QString> m_map;
     QHash<QString, QString> m_name;
     KateExternalToolsPlugin* m_plugin;
 };
 
 /**
  * A Dialog to edit a single KateExternalTool object
  */
 class KateExternalToolServiceEditor : public QDialog
 {
     Q_OBJECT
 
 public:
     explicit KateExternalToolServiceEditor(KateExternalTool* tool = nullptr, QWidget* parent = nullptr);
 
-    class QLineEdit *leName, *leExecutable, *leMimetypes, *leCmdLine;
-    class QTextEdit* teCommand;
-    class KIconButton* btnIcon;
-    class QComboBox* cmbSave;
-
 private Q_SLOTS:
     /**
      * Run when the OK button is clicked, to ensure critical values are provided.
      */
     void slotOKClicked();
+
     /**
      * show a mimetype chooser dialog
      */
     void showMTDlg();
 
+public:
+    Ui::ToolDialog * ui;
 private:
     KateExternalTool* tool;
 };
 
 #endif // KTEXTEDITOR_EXTERNALTOOLS_H
 
 // kate: space-indent on; indent-width 4; replace-tabs on;
diff --git a/addons/externaltools/tooldialog.ui b/addons/externaltools/tooldialog.ui
new file mode 100644
index 000000000..ab72e6883
--- /dev/null
+++ b/addons/externaltools/tooldialog.ui
@@ -0,0 +1,353 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<ui version="4.0">
+ <class>ToolDialog</class>
+ <widget class="QDialog" name="ToolDialog">
+  <property name="geometry">
+   <rect>
+    <x>0</x>
+    <y>0</y>
+    <width>470</width>
+    <height>491</height>
+   </rect>
+  </property>
+  <property name="windowTitle">
+   <string>Edit Tool</string>
+  </property>
+  <layout class="QFormLayout" name="formLayout">
+   <item row="0" column="0">
+    <widget class="QLabel" name="lblName">
+     <property name="text">
+      <string>Name:</string>
+     </property>
+    </widget>
+   </item>
+   <item row="0" column="1">
+    <layout class="QHBoxLayout" name="horizontalLayout_2">
+     <item>
+      <widget class="QLineEdit" name="edtName">
+       <property name="whatsThis">
+        <string>The name will be displayed in the 'Tools-&gt;External Tools' menu.</string>
+       </property>
+       <property name="placeholderText">
+        <string>Short name of the tool</string>
+       </property>
+      </widget>
+     </item>
+     <item>
+      <widget class="KIconButton" name="btnIcon"/>
+     </item>
+    </layout>
+   </item>
+   <item row="1" column="0">
+    <widget class="QLabel" name="lblExecutable">
+     <property name="text">
+      <string>Executable:</string>
+     </property>
+    </widget>
+   </item>
+   <item row="1" column="1">
+    <layout class="QHBoxLayout" name="horizontalLayout_3">
+     <item>
+      <widget class="QLineEdit" name="edtExecutable">
+       <property name="whatsThis">
+        <string>The executable used by the command. This is used to check if a tool should be displayed; if not set, the first word of &lt;em&gt;command&lt;/em&gt; will be used.</string>
+       </property>
+       <property name="placeholderText">
+        <string>Application or interpreter</string>
+       </property>
+      </widget>
+     </item>
+     <item>
+      <widget class="QToolButton" name="btnExecutable">
+       <property name="icon">
+        <iconset theme="folder-open">
+         <normaloff>../../../../../../../../.designer/backup</normaloff>../../../../../../../../.designer/backup</iconset>
+       </property>
+       <property name="popupMode">
+        <enum>QToolButton::InstantPopup</enum>
+       </property>
+      </widget>
+     </item>
+    </layout>
+   </item>
+   <item row="2" column="0">
+    <widget class="QLabel" name="lblArgs">
+     <property name="text">
+      <string>Arguments:</string>
+     </property>
+    </widget>
+   </item>
+   <item row="3" column="0">
+    <widget class="QLabel" name="lblInput">
+     <property name="text">
+      <string>Input:</string>
+     </property>
+    </widget>
+   </item>
+   <item row="3" column="1">
+    <layout class="QHBoxLayout" name="loArgs">
+     <item>
+      <widget class="QTextEdit" name="edtInput">
+       <property name="whatsThis">
+        <string>&lt;p&gt;The script to execute to invoke the tool. The script is passed to /bin/sh for execution. The following macros will be expanded:&lt;/p&gt;&lt;ul&gt;&lt;li&gt;&lt;code&gt;%URL&lt;/code&gt; - the URL of the current document.&lt;/li&gt;&lt;li&gt;&lt;code&gt;%URLs&lt;/code&gt; - a list of the URLs of all open documents.&lt;/li&gt;&lt;li&gt;&lt;code&gt;%directory&lt;/code&gt; - the URL of the directory containing the current document.&lt;/li&gt;&lt;li&gt;&lt;code&gt;%filename&lt;/code&gt; - the filename of the current document.&lt;/li&gt;&lt;li&gt;&lt;code&gt;%line&lt;/code&gt; - the current line of the text cursor in the current view.&lt;/li&gt;&lt;li&gt;&lt;code&gt;%column&lt;/code&gt; - the column of the text cursor in the current view.&lt;/li&gt;&lt;li&gt;&lt;code&gt;%selection&lt;/code&gt; - the selected text in the current view.&lt;/li&gt;&lt;li&gt;&lt;code&gt;%text&lt;/code&gt; - the text of the current document.&lt;/li&gt;&lt;/ul&gt;</string>
+       </property>
+       <property name="placeholderText">
+        <string>Optional standard input</string>
+       </property>
+      </widget>
+     </item>
+     <item alignment="Qt::AlignTop">
+      <widget class="QToolButton" name="btnInput">
+       <property name="icon">
+        <iconset theme="arrow-down">
+         <normaloff>../../../../../../../../.designer/backup</normaloff>../../../../../../../../.designer/backup</iconset>
+       </property>
+       <property name="popupMode">
+        <enum>QToolButton::InstantPopup</enum>
+       </property>
+      </widget>
+     </item>
+    </layout>
+   </item>
+   <item row="5" column="0">
+    <widget class="QLabel" name="lblMimeType">
+     <property name="text">
+      <string>Mime types:</string>
+     </property>
+    </widget>
+   </item>
+   <item row="5" column="1">
+    <layout class="QHBoxLayout" name="horizontalLayout">
+     <item>
+      <widget class="QLineEdit" name="edtMimeType">
+       <property name="whatsThis">
+        <string>A semicolon-separated list of mime types for which this tool should be available; if this is left empty, the tool is always available. To choose from known mimetypes, press the button on the right.</string>
+       </property>
+       <property name="placeholderText">
+        <string>Show tool only for given mime types</string>
+       </property>
+      </widget>
+     </item>
+     <item>
+      <widget class="QToolButton" name="btnMimeType">
+       <property name="whatsThis">
+        <string>Click for a dialog that can help you create a list of mimetypes.</string>
+       </property>
+       <property name="icon">
+        <iconset theme="tools-wizard">
+         <normaloff>../../../../../../../../.designer/backup</normaloff>../../../../../../../../.designer/backup</iconset>
+       </property>
+      </widget>
+     </item>
+    </layout>
+   </item>
+   <item row="6" column="0">
+    <widget class="QLabel" name="lblSave">
+     <property name="text">
+      <string>Save:</string>
+     </property>
+    </widget>
+   </item>
+   <item row="6" column="1">
+    <widget class="QComboBox" name="cmbSave">
+     <property name="whatsThis">
+      <string>You can choose to save the current or all [modified] documents prior to running the command. This is helpful if you want to pass URLs to an application like, for example, an FTP client.</string>
+     </property>
+     <item>
+      <property name="text">
+       <string>None</string>
+      </property>
+     </item>
+     <item>
+      <property name="text">
+       <string>Current Document</string>
+      </property>
+     </item>
+     <item>
+      <property name="text">
+       <string>All Documents</string>
+      </property>
+     </item>
+    </widget>
+   </item>
+   <item row="7" column="1">
+    <widget class="QCheckBox" name="chkReload">
+     <property name="text">
+      <string>Reload current document after execution</string>
+     </property>
+    </widget>
+   </item>
+   <item row="8" column="0">
+    <widget class="QLabel" name="label">
+     <property name="text">
+      <string>Output:</string>
+     </property>
+    </widget>
+   </item>
+   <item row="8" column="1">
+    <widget class="QComboBox" name="cmbOutput">
+     <item>
+      <property name="text">
+       <string>Ignore</string>
+      </property>
+     </item>
+     <item>
+      <property name="text">
+       <string>Insert at Cursor Position</string>
+      </property>
+     </item>
+     <item>
+      <property name="text">
+       <string>Replace Selected Text</string>
+      </property>
+     </item>
+     <item>
+      <property name="text">
+       <string>Replace Current Document</string>
+      </property>
+     </item>
+     <item>
+      <property name="text">
+       <string>Append to Current Document</string>
+      </property>
+     </item>
+     <item>
+      <property name="text">
+       <string>Insert in New Document</string>
+      </property>
+     </item>
+     <item>
+      <property name="text">
+       <string>Display in Pane</string>
+      </property>
+     </item>
+     <item>
+      <property name="text">
+       <string>Embedded Console</string>
+      </property>
+     </item>
+    </widget>
+   </item>
+   <item row="9" column="0">
+    <widget class="QLabel" name="label_6">
+     <property name="text">
+      <string>Editor command:</string>
+     </property>
+    </widget>
+   </item>
+   <item row="9" column="1">
+    <widget class="QLineEdit" name="edtCommand">
+     <property name="whatsThis">
+      <string>If you specify a name here, you can invoke the command from the view command line with exttool-the_name_you_specified_here. Please do not use spaces or tabs in the name.</string>
+     </property>
+     <property name="placeholderText">
+      <string>Optional command bar name</string>
+     </property>
+    </widget>
+   </item>
+   <item row="10" column="1">
+    <widget class="QDialogButtonBox" name="buttonBox">
+     <property name="orientation">
+      <enum>Qt::Horizontal</enum>
+     </property>
+     <property name="standardButtons">
+      <set>QDialogButtonBox::Cancel|QDialogButtonBox::Ok</set>
+     </property>
+    </widget>
+   </item>
+   <item row="4" column="0">
+    <widget class="QLabel" name="lblWorkingDir">
+     <property name="text">
+      <string>Working directory:</string>
+     </property>
+    </widget>
+   </item>
+   <item row="4" column="1">
+    <layout class="QHBoxLayout" name="horizontalLayout_4">
+     <item>
+      <widget class="QLineEdit" name="edtWorkingDir">
+       <property name="placeholderText">
+        <string>Uses current document path if empty</string>
+       </property>
+      </widget>
+     </item>
+     <item>
+      <widget class="QToolButton" name="btnWorkingDir">
+       <property name="icon">
+        <iconset theme="folder-open">
+         <normaloff>../../../../../../../../.designer/backup</normaloff>../../../../../../../../.designer/backup</iconset>
+       </property>
+       <property name="popupMode">
+        <enum>QToolButton::InstantPopup</enum>
+       </property>
+      </widget>
+     </item>
+    </layout>
+   </item>
+   <item row="2" column="1">
+    <layout class="QHBoxLayout" name="horizontalLayout_5">
+     <item>
+      <widget class="QLineEdit" name="edtArgs">
+       <property name="placeholderText">
+        <string>Command line arguments</string>
+       </property>
+      </widget>
+     </item>
+     <item>
+      <widget class="QToolButton" name="btnArgs">
+       <property name="icon">
+        <iconset theme="arrow-down">
+         <normaloff>../../../../../../../../.designer/backup</normaloff>../../../../../../../../.designer/backup</iconset>
+       </property>
+       <property name="popupMode">
+        <enum>QToolButton::InstantPopup</enum>
+       </property>
+      </widget>
+     </item>
+    </layout>
+   </item>
+  </layout>
+ </widget>
+ <customwidgets>
+  <customwidget>
+   <class>KIconButton</class>
+   <extends>QPushButton</extends>
+   <header>kiconbutton.h</header>
+  </customwidget>
+ </customwidgets>
+ <resources/>
+ <connections>
+  <connection>
+   <sender>buttonBox</sender>
+   <signal>accepted()</signal>
+   <receiver>ToolDialog</receiver>
+   <slot>accept()</slot>
+   <hints>
+    <hint type="sourcelabel">
+     <x>248</x>
+     <y>254</y>
+    </hint>
+    <hint type="destinationlabel">
+     <x>157</x>
+     <y>274</y>
+    </hint>
+   </hints>
+  </connection>
+  <connection>
+   <sender>buttonBox</sender>
+   <signal>rejected()</signal>
+   <receiver>ToolDialog</receiver>
+   <slot>reject()</slot>
+   <hints>
+    <hint type="sourcelabel">
+     <x>316</x>
+     <y>260</y>
+    </hint>
+    <hint type="destinationlabel">
+     <x>286</x>
+     <y>274</y>
+    </hint>
+   </hints>
+  </connection>
+ </connections>
+</ui>