feedc0de/qt-creator
1
0
Fork 0
forked from qt-creator/qt-creator
Code Pull Requests Activity

Core: Clean up ExternalToolsManager interface

Browse Source 
Change-Id: I8ea81de7350bdb0c6243d65596196d615845ffc4
Reviewed-by: David Schulz <david.schulz@digia.com>
This commit is contained in:
hjk
2013-09-05 18:48:06 +02:00
parent 9d1cc97126
commit 61a8257b68
3 changed files with 98 additions and 100 deletions
Download Patch File Download Diff File Expand all files Collapse all files

144
src/plugins/coreplugin/externaltool.cpp
View File

@@ -447,11 +447,11 @@ ExternalTool * ExternalTool::createFromFile(const QString &fileName, QString *er
static QLatin1String stringForOutputHandling(ExternalTool::OutputHandling handling) static QLatin1String stringForOutputHandling(ExternalTool::OutputHandling handling)
{ {
switch (handling) { switch (handling) {
case Core::Internal::ExternalTool::Ignore: case ExternalTool::Ignore:
return QLatin1String(kOutputIgnore); return QLatin1String(kOutputIgnore);
case Core::Internal::ExternalTool::ShowInPane: case ExternalTool::ShowInPane:
return QLatin1String(kOutputShowInPane); return QLatin1String(kOutputShowInPane);
case Core::Internal::ExternalTool::ReplaceSelection: case ExternalTool::ReplaceSelection:
return QLatin1String(kOutputReplaceSelection); return QLatin1String(kOutputReplaceSelection);
} }
return QLatin1String(""); return QLatin1String("");
@@ -627,7 +627,7 @@ void ExternalToolRunner::finished(int exitCode, QProcess::ExitStatus status)
if (status == QProcess::NormalExit && exitCode == 0) { if (status == QProcess::NormalExit && exitCode == 0) {
if (m_tool->outputHandling() == ExternalTool::ReplaceSelection if (m_tool->outputHandling() == ExternalTool::ReplaceSelection
|| m_tool->errorHandling() == ExternalTool::ReplaceSelection) { || m_tool->errorHandling() == ExternalTool::ReplaceSelection) {
emit ExternalToolManager::instance()->replaceSelectionRequested(m_processOutput); ExternalToolManager::emitReplaceSelectionRequested(m_processOutput);
} }
if (m_tool->modifiesCurrentDocument()) if (m_tool->modifiesCurrentDocument())
DocumentManager::unexpectFileChange(m_expectedFileName); DocumentManager::unexpectFileChange(m_expectedFileName);
@@ -670,34 +670,44 @@ void ExternalToolRunner::readStandardError()
m_processOutput.append(output); m_processOutput.append(output);
} }
// #pragma mark -- ExternalToolManager // ExternalToolManager
ExternalToolManager *ExternalToolManager::m_instance = 0; struct ExternalToolManagerPrivate
{
QMap<QString, ExternalTool *> m_tools;
QMap<QString, QList<ExternalTool *> > m_categoryMap;
QMap<QString, QAction *> m_actions;
QMap<QString, ActionContainer *> m_containers;
QAction *m_configureSeparator;
QAction *m_configureAction;
};
static ExternalToolManager *m_instance = 0;
static ExternalToolManagerPrivate *d = 0;
static void writeSettings();
static void readSettings(const QMap<QString, ExternalTool *> &tools,
QMap<QString, QList<ExternalTool*> > *categoryPriorityMap);
static void parseDirectory(const QString &directory,
QMap<QString, QMultiMap<int, ExternalTool*> > *categoryMenus,
QMap<QString, ExternalTool *> *tools,
bool isPreset = false);
ExternalToolManager::ExternalToolManager() ExternalToolManager::ExternalToolManager()
: QObject(ICore::instance()) : QObject(ICore::instance())
{ {
m_instance = this; m_instance = this;
initialize(); d = new ExternalToolManagerPrivate;
}
ExternalToolManager::~ExternalToolManager() d->m_configureSeparator = new QAction(this);
{ d->m_configureSeparator->setSeparator(true);
writeSettings(); d->m_configureAction = new QAction(tr("Configure..."), this);
// TODO kill running tools connect(d->m_configureAction, SIGNAL(triggered()), this, SLOT(openPreferences()));
qDeleteAll(m_tools);
}
void ExternalToolManager::initialize()
{
m_configureSeparator = new QAction(this);
m_configureSeparator->setSeparator(true);
m_configureAction = new QAction(tr("Configure..."), this);
connect(m_configureAction, SIGNAL(triggered()), this, SLOT(openPreferences()));
// add the external tools menu // add the external tools menu
ActionContainer *mexternaltools = ActionManager::createMenu(Id(Constants::M_TOOLS_EXTERNAL)); ActionContainer *mexternaltools = ActionManager::createMenu(Id(Constants::M_TOOLS_EXTERNAL));
mexternaltools->menu()->setTitle(tr("&External")); mexternaltools->menu()->setTitle(ExternalToolManager::tr("&External"));
ActionContainer *mtools = ActionManager::actionContainer(Constants::M_TOOLS); ActionContainer *mtools = ActionManager::actionContainer(Constants::M_TOOLS);
mtools->addMenu(mexternaltools, Constants::G_DEFAULT_THREE); mtools->addMenu(mexternaltools, Constants::G_DEFAULT_THREE);
@@ -711,7 +721,7 @@ void ExternalToolManager::initialize()
&tools, &tools,
true); true);
QMap<QString, QList<Internal::ExternalTool *> > categoryMap; QMap<QString, QList<ExternalTool *> > categoryMap;
QMapIterator<QString, QMultiMap<int, ExternalTool*> > it(categoryPriorityMap); QMapIterator<QString, QMultiMap<int, ExternalTool*> > it(categoryPriorityMap);
while (it.hasNext()) { while (it.hasNext()) {
it.next(); it.next();
@@ -723,8 +733,21 @@ void ExternalToolManager::initialize()
setToolsByCategory(categoryMap); setToolsByCategory(categoryMap);
} }
void ExternalToolManager::parseDirectory(const QString &directory, ExternalToolManager::~ExternalToolManager()
QMap<QString, QMultiMap<int, Internal::ExternalTool*> > *categoryMenus, {
writeSettings();
// TODO kill running tools
qDeleteAll(d->m_tools);
delete d;
}
QObject *ExternalToolManager::instance()
{
return m_instance;
}
static void parseDirectory(const QString &directory,
QMap<QString, QMultiMap<int, ExternalTool*> > *categoryMenus,
QMap<QString, ExternalTool *> *tools, QMap<QString, ExternalTool *> *tools,
bool isPreset) bool isPreset)
{ {
@@ -736,7 +759,7 @@ void ExternalToolManager::parseDirectory(const QString &directory,
QString error; QString error;
ExternalTool *tool = ExternalTool::createFromFile(fileName, &error, ICore::userInterfaceLanguage()); ExternalTool *tool = ExternalTool::createFromFile(fileName, &error, ICore::userInterfaceLanguage());
if (!tool) { if (!tool) {
qWarning() << tr("Error while parsing external tool %1: %2").arg(fileName, error); qWarning() << ExternalTool::tr("Error while parsing external tool %1: %2").arg(fileName, error);
continue; continue;
} }
if (tools->contains(tool->id())) { if (tools->contains(tool->id())) {
@@ -745,7 +768,7 @@ void ExternalToolManager::parseDirectory(const QString &directory,
ExternalTool *other = tools->value(tool->id()); ExternalTool *other = tools->value(tool->id());
other->setPreset(QSharedPointer<ExternalTool>(tool)); other->setPreset(QSharedPointer<ExternalTool>(tool));
} else { } else {
qWarning() << tr("Error: External tool in %1 has duplicate id").arg(fileName); qWarning() << ExternalToolManager::tr("Error: External tool in %1 has duplicate id").arg(fileName);
delete tool; delete tool;
} }
continue; continue;
@@ -763,24 +786,24 @@ void ExternalToolManager::menuActivated()
{ {
QAction *action = qobject_cast<QAction *>(sender()); QAction *action = qobject_cast<QAction *>(sender());
QTC_ASSERT(action, return); QTC_ASSERT(action, return);
ExternalTool *tool = m_tools.value(action->data().toString()); ExternalTool *tool = d->m_tools.value(action->data().toString());
QTC_ASSERT(tool, return); QTC_ASSERT(tool, return);
ExternalToolRunner *runner = new ExternalToolRunner(tool); ExternalToolRunner *runner = new ExternalToolRunner(tool);
if (runner->hasError()) if (runner->hasError())
MessageManager::write(runner->errorString()); MessageManager::write(runner->errorString());
} }
QMap<QString, QList<Internal::ExternalTool *> > ExternalToolManager::toolsByCategory() const QMap<QString, QList<ExternalTool *> > ExternalToolManager::toolsByCategory()
{ {
return m_categoryMap; return d->m_categoryMap;
} }
QMap<QString, ExternalTool *> ExternalToolManager::toolsById() const QMap<QString, ExternalTool *> ExternalToolManager::toolsById()
{ {
return m_tools; return d->m_tools;
} }
void ExternalToolManager::setToolsByCategory(const QMap<QString, QList<Internal::ExternalTool *> > &tools) void ExternalToolManager::setToolsByCategory(const QMap<QString, QList<ExternalTool *> > &tools)
{ {
// clear menu // clear menu
ActionContainer *mexternaltools = ActionManager::actionContainer(Id(Constants::M_TOOLS_EXTERNAL)); ActionContainer *mexternaltools = ActionManager::actionContainer(Id(Constants::M_TOOLS_EXTERNAL));
@@ -793,18 +816,18 @@ void ExternalToolManager::setToolsByCategory(const QMap<QString, QList<Internal:
while (it.hasNext()) { while (it.hasNext()) {
it.next(); it.next();
foreach (ExternalTool *tool, it.value()) { foreach (ExternalTool *tool, it.value()) {
const QString &id = tool->id(); const QString id = tool->id();
if (m_tools.value(id) == tool) { if (d->m_tools.value(id) == tool) {
newActions.insert(id, m_actions.value(id)); newActions.insert(id, d->m_actions.value(id));
// remove from list to prevent deletion // remove from list to prevent deletion
m_tools.remove(id); d->m_tools.remove(id);
m_actions.remove(id); d->m_actions.remove(id);
} }
newTools.insert(id, tool); newTools.insert(id, tool);
} }
} }
qDeleteAll(m_tools); qDeleteAll(d->m_tools);
QMapIterator<QString, QAction *> remainingActions(m_actions); QMapIterator<QString, QAction *> remainingActions(d->m_actions);
const Id externalToolsPrefix = "Tools.External."; const Id externalToolsPrefix = "Tools.External.";
while (remainingActions.hasNext()) { while (remainingActions.hasNext()) {
remainingActions.next(); remainingActions.next();
@@ -812,11 +835,11 @@ void ExternalToolManager::setToolsByCategory(const QMap<QString, QList<Internal:
externalToolsPrefix.withSuffix(remainingActions.key())); externalToolsPrefix.withSuffix(remainingActions.key()));
delete remainingActions.value(); delete remainingActions.value();
} }
m_actions.clear(); d->m_actions.clear();
// assign the new stuff // assign the new stuff
m_tools = newTools; d->m_tools = newTools;
m_actions = newActions; d->m_actions = newActions;
m_categoryMap = tools; d->m_categoryMap = tools;
// create menu structure and remove no-longer used containers // create menu structure and remove no-longer used containers
// add all the category menus, QMap is nicely sorted // add all the category menus, QMap is nicely sorted
QMap<QString, ActionContainer *> newContainers; QMap<QString, ActionContainer *> newContainers;
@@ -828,8 +851,8 @@ void ExternalToolManager::setToolsByCategory(const QMap<QString, QList<Internal:
if (containerName.isEmpty()) { // no displayCategory, so put into external tools menu directly if (containerName.isEmpty()) { // no displayCategory, so put into external tools menu directly
container = mexternaltools; container = mexternaltools;
} else { } else {
if (m_containers.contains(containerName)) if (d->m_containers.contains(containerName))
container = m_containers.take(containerName); // remove to avoid deletion below container = d->m_containers.take(containerName); // remove to avoid deletion below
else else
container = ActionManager::createMenu(Id("Tools.External.Category.").withSuffix(containerName)); container = ActionManager::createMenu(Id("Tools.External.Category.").withSuffix(containerName));
newContainers.insert(containerName, container); newContainers.insert(containerName, container);
@@ -841,14 +864,14 @@ void ExternalToolManager::setToolsByCategory(const QMap<QString, QList<Internal:
// tool action and command // tool action and command
QAction *action = 0; QAction *action = 0;
Command *command = 0; Command *command = 0;
if (m_actions.contains(toolId)) { if (d->m_actions.contains(toolId)) {
action = m_actions.value(toolId); action = d->m_actions.value(toolId);
command = ActionManager::command(externalToolsPrefix.withSuffix(toolId)); command = ActionManager::command(externalToolsPrefix.withSuffix(toolId));
} else { } else {
action = new QAction(tool->displayName(), this); action = new QAction(tool->displayName(), m_instance);
action->setData(toolId); action->setData(toolId);
m_actions.insert(toolId, action); d->m_actions.insert(toolId, action);
connect(action, SIGNAL(triggered()), this, SLOT(menuActivated())); connect(action, SIGNAL(triggered()), m_instance, SLOT(menuActivated()));
command = ActionManager::registerAction(action, externalToolsPrefix.withSuffix(toolId), Context(Constants::C_GLOBAL)); command = ActionManager::registerAction(action, externalToolsPrefix.withSuffix(toolId), Context(Constants::C_GLOBAL));
command->setAttribute(Command::CA_UpdateText); command->setAttribute(Command::CA_UpdateText);
} }
@@ -860,16 +883,16 @@ void ExternalToolManager::setToolsByCategory(const QMap<QString, QList<Internal:
} }
// delete the unused containers // delete the unused containers
qDeleteAll(m_containers); qDeleteAll(d->m_containers);
// remember the new containers // remember the new containers
m_containers = newContainers; d->m_containers = newContainers;
// (re)add the configure menu item // (re)add the configure menu item
mexternaltools->menu()->addAction(m_configureSeparator); mexternaltools->menu()->addAction(d->m_configureSeparator);
mexternaltools->menu()->addAction(m_configureAction); mexternaltools->menu()->addAction(d->m_configureAction);
} }
void ExternalToolManager::readSettings(const QMap<QString, ExternalTool *> &tools, static void readSettings(const QMap<QString, ExternalTool *> &tools,
QMap<QString, QList<ExternalTool *> > *categoryMap) QMap<QString, QList<ExternalTool *> > *categoryMap)
{ {
QSettings *settings = ICore::settings(); QSettings *settings = ICore::settings();
@@ -903,14 +926,14 @@ void ExternalToolManager::readSettings(const QMap<QString, ExternalTool *> &tool
settings->endGroup(); settings->endGroup();
} }
void ExternalToolManager::writeSettings() static void writeSettings()
{ {
QSettings *settings = ICore::settings(); QSettings *settings = ICore::settings();
settings->beginGroup(QLatin1String("ExternalTools")); settings->beginGroup(QLatin1String("ExternalTools"));
settings->remove(QLatin1String("")); settings->remove(QLatin1String(""));
settings->beginGroup(QLatin1String("OverrideCategories")); settings->beginGroup(QLatin1String("OverrideCategories"));
QMapIterator<QString, QList<ExternalTool *> > it(m_categoryMap); QMapIterator<QString, QList<ExternalTool *> > it(d->m_categoryMap);
while (it.hasNext()) { while (it.hasNext()) {
it.next(); it.next();
QString category = it.key(); QString category = it.key();
@@ -934,3 +957,8 @@ void ExternalToolManager::openPreferences()
{ {
ICore::showOptionsDialog(Constants::SETTINGS_CATEGORY_CORE, Constants::SETTINGS_ID_TOOLS); ICore::showOptionsDialog(Constants::SETTINGS_CATEGORY_CORE, Constants::SETTINGS_ID_TOOLS);
} }
void ExternalToolManager::emitReplaceSelectionRequested(const QString &output)
{
emit m_instance->replaceSelectionRequested(output);
}

42
src/plugins/coreplugin/externaltoolmanager.h
View File

@@ -37,30 +37,23 @@
#include <QList> #include <QList>
#include <QString> #include <QString>
QT_FORWARD_DECLARE_CLASS(QAction)
namespace Core { namespace Core {
class ActionContainer;
namespace Internal { namespace Internal { class ExternalTool; }
class ExternalToolRunner;
class ExternalTool;
}
class CORE_EXPORT ExternalToolManager : public QObject class CORE_EXPORT ExternalToolManager : public QObject
{ {
Q_OBJECT Q_OBJECT
public: public:
static ExternalToolManager *instance() { return m_instance; }
ExternalToolManager(); ExternalToolManager();
~ExternalToolManager(); ~ExternalToolManager();
QMap<QString, QList<Internal::ExternalTool *> > toolsByCategory() const; static QObject *instance();
QMap<QString, Internal::ExternalTool *> toolsById() const; static QMap<QString, QList<Internal::ExternalTool *> > toolsByCategory();
static QMap<QString, Internal::ExternalTool *> toolsById();
void setToolsByCategory(const QMap<QString, QList<Internal::ExternalTool *> > &tools); static void setToolsByCategory(const QMap<QString, QList<Internal::ExternalTool *> > &tools);
static void emitReplaceSelectionRequested(const QString &output);
signals: signals:
void replaceSelectionRequested(const QString &text); void replaceSelectionRequested(const QString &text);
@@ -68,30 +61,9 @@ signals:
private slots: private slots:
void menuActivated(); void menuActivated();
void openPreferences(); void openPreferences();
private:
void initialize();
void parseDirectory(const QString &directory,
QMap<QString, QMultiMap<int, Internal::ExternalTool*> > *categoryMenus,
QMap<QString, Internal::ExternalTool *> *tools,
bool isPreset = false);
void readSettings(const QMap<QString, Internal::ExternalTool *> &tools,
QMap<QString, QList<Internal::ExternalTool*> > *categoryPriorityMap);
void writeSettings();
static ExternalToolManager *m_instance;
QMap<QString, Internal::ExternalTool *> m_tools;
QMap<QString, QList<Internal::ExternalTool *> > m_categoryMap;
QMap<QString, QAction *> m_actions;
QMap<QString, ActionContainer *> m_containers;
QAction *m_configureSeparator;
QAction *m_configureAction;
// for sending the replaceSelectionRequested signal
friend class Core::Internal::ExternalToolRunner;
}; };
} // Core } // namespace Core
#endif // EXTERNALTOOLMANAGER_H #endif // EXTERNALTOOLMANAGER_H

8
src/plugins/coreplugin/toolsettings.cpp
View File

@@ -64,13 +64,12 @@ bool ToolSettings::matches(const QString & searchKeyWord) const
QWidget *ToolSettings::createPage(QWidget *parent) QWidget *ToolSettings::createPage(QWidget *parent)
{ {
m_widget = new ExternalToolConfig(parent); m_widget = new ExternalToolConfig(parent);
m_widget->setTools(ExternalToolManager::instance()->toolsByCategory()); m_widget->setTools(ExternalToolManager::toolsByCategory());
if (m_searchKeywords.isEmpty()) if (m_searchKeywords.isEmpty())
m_searchKeywords = m_widget->searchKeywords(); m_searchKeywords = m_widget->searchKeywords();
return m_widget; return m_widget;
} }
static QString getUserFilePath(const QString &proposalFileName) static QString getUserFilePath(const QString &proposalFileName)
{ {
QDir resourceDir(ICore::userResourcePath()); QDir resourceDir(ICore::userResourcePath());
@@ -132,7 +131,7 @@ void ToolSettings::apply()
if (!m_widget) if (!m_widget)
return; return;
m_widget->apply(); m_widget->apply();
QMap<QString, ExternalTool *> originalTools = ExternalToolManager::instance()->toolsById(); QMap<QString, ExternalTool *> originalTools = ExternalToolManager::toolsById();
QMap<QString, QList<ExternalTool *> > newToolsMap = m_widget->tools(); QMap<QString, QList<ExternalTool *> > newToolsMap = m_widget->tools();
QMap<QString, QList<ExternalTool *> > resultMap; QMap<QString, QList<ExternalTool *> > resultMap;
QMapIterator<QString, QList<ExternalTool *> > it(newToolsMap); QMapIterator<QString, QList<ExternalTool *> > it(newToolsMap);
@@ -202,10 +201,9 @@ void ToolSettings::apply()
QFile::remove(tool->fileName()); QFile::remove(tool->fileName());
} }
ExternalToolManager::instance()->setToolsByCategory(resultMap); ExternalToolManager::setToolsByCategory(resultMap);
} }
void ToolSettings::finish() void ToolSettings::finish()
{ {
} }