1 /**************************************************************************
3 ** This file is part of Qt Creator
5 ** Copyright (c) 2011 Nokia Corporation and/or its subsidiary(-ies).
7 ** Contact: Nokia Corporation (qt-info@nokia.com)
11 ** This file contains pre-release code and may not be distributed.
12 ** You may use this file in accordance with the terms and conditions
13 ** contained in the Technology Preview License Agreement accompanying
16 ** GNU Lesser General Public License Usage
18 ** Alternatively, this file may be used under the terms of the GNU Lesser
19 ** General Public License version 2.1 as published by the Free Software
20 ** Foundation and appearing in the file LICENSE.LGPL included in the
21 ** packaging of this file. Please review the following information to
22 ** ensure the GNU Lesser General Public License version 2.1 requirements
23 ** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
25 ** In addition, as a special exception, Nokia gives you certain additional
26 ** rights. These rights are described in the Nokia Qt LGPL Exception
27 ** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.
29 ** If you have questions regarding the use of this file, please contact
30 ** Nokia at qt-info@nokia.com.
32 **************************************************************************/
34 #include "cmakerunconfiguration.h"
36 #include "cmakebuildconfiguration.h"
37 #include "cmakeproject.h"
38 #include "cmakeprojectconstants.h"
39 #include "cmaketarget.h"
41 #include <coreplugin/coreconstants.h>
42 #include <projectexplorer/debugginghelper.h>
43 #include <utils/qtcassert.h>
44 #include <utils/debuggerlanguagechooser.h>
45 #include <QtGui/QFormLayout>
46 #include <QtGui/QLineEdit>
47 #include <QtGui/QGroupBox>
48 #include <QtGui/QLabel>
49 #include <QtGui/QComboBox>
50 #include <QtGui/QToolButton>
52 using namespace CMakeProjectManager;
53 using namespace CMakeProjectManager::Internal;
56 const char * const CMAKE_RC_ID("CMakeProjectManager.CMakeRunConfiguration");
57 const char * const CMAKE_RC_PREFIX("CMakeProjectManager.CMakeRunConfiguration.");
59 const char * const USER_WORKING_DIRECTORY_KEY("CMakeProjectManager.CMakeRunConfiguration.UserWorkingDirectory");
60 const char * const USE_TERMINAL_KEY("CMakeProjectManager.CMakeRunConfiguration.UseTerminal");
61 const char * const TITLE_KEY("CMakeProjectManager.CMakeRunConfiguation.Title");
62 const char * const ARGUMENTS_KEY("CMakeProjectManager.CMakeRunConfiguration.Arguments");
63 const char * const USER_ENVIRONMENT_CHANGES_KEY("CMakeProjectManager.CMakeRunConfiguration.UserEnvironmentChanges");
64 const char * const BASE_ENVIRONMENT_BASE_KEY("CMakeProjectManager.BaseEnvironmentBase");
66 QString buildTargetFromId(const QString &id)
68 if (!id.startsWith(QLatin1String(CMAKE_RC_PREFIX)))
70 return id.mid(QString::fromLatin1(CMAKE_RC_PREFIX).length());
73 QString idFromBuildTarget(const QString &target)
75 return QString::fromLatin1(CMAKE_RC_PREFIX) + target;
80 CMakeRunConfiguration::CMakeRunConfiguration(CMakeTarget *parent, const QString &target, const QString &workingDirectory, const QString &title) :
81 ProjectExplorer::LocalApplicationRunConfiguration(parent, QString::fromLatin1(CMAKE_RC_PREFIX)),
83 m_buildTarget(target),
84 m_workingDirectory(workingDirectory),
86 m_baseEnvironmentBase(CMakeRunConfiguration::BuildEnvironmentBase),
92 CMakeRunConfiguration::CMakeRunConfiguration(CMakeTarget *parent, CMakeRunConfiguration *source) :
93 ProjectExplorer::LocalApplicationRunConfiguration(parent, source),
94 m_runMode(source->m_runMode),
95 m_buildTarget(source->m_buildTarget),
96 m_workingDirectory(source->m_workingDirectory),
97 m_userWorkingDirectory(source->m_userWorkingDirectory),
98 m_title(source->m_title),
99 m_arguments(source->m_arguments),
100 m_userEnvironmentChanges(source->m_userEnvironmentChanges),
101 m_baseEnvironmentBase(source->m_baseEnvironmentBase),
102 m_enabled(source->m_enabled)
107 CMakeRunConfiguration::~CMakeRunConfiguration()
111 void CMakeRunConfiguration::ctor()
113 setDefaultDisplayName(defaultDisplayName());
116 CMakeTarget *CMakeRunConfiguration::cmakeTarget() const
118 return static_cast<CMakeTarget *>(target());
121 CMakeBuildConfiguration *CMakeRunConfiguration::activeBuildConfiguration() const
123 return cmakeTarget()->activeBuildConfiguration();
126 QString CMakeRunConfiguration::executable() const
128 return m_buildTarget;
131 ProjectExplorer::LocalApplicationRunConfiguration::RunMode CMakeRunConfiguration::runMode() const
136 QString CMakeRunConfiguration::workingDirectory() const
138 return QDir::cleanPath(environment().expandVariables(
139 Utils::expandMacros(baseWorkingDirectory(), macroExpander())));
142 QString CMakeRunConfiguration::baseWorkingDirectory() const
144 if (!m_userWorkingDirectory.isEmpty())
145 return m_userWorkingDirectory;
146 return m_workingDirectory;
149 QString CMakeRunConfiguration::commandLineArguments() const
151 return Utils::QtcProcess::expandMacros(m_arguments, macroExpander());
154 QString CMakeRunConfiguration::title() const
159 void CMakeRunConfiguration::setExecutable(const QString &executable)
161 m_buildTarget = executable;
164 void CMakeRunConfiguration::setBaseWorkingDirectory(const QString &wd)
166 const QString &oldWorkingDirectory = workingDirectory();
168 m_workingDirectory = wd;
170 const QString &newWorkingDirectory = workingDirectory();
171 if (oldWorkingDirectory != newWorkingDirectory)
172 emit baseWorkingDirectoryChanged(newWorkingDirectory);
175 void CMakeRunConfiguration::setUserWorkingDirectory(const QString &wd)
177 const QString & oldWorkingDirectory = workingDirectory();
179 m_userWorkingDirectory = wd;
181 const QString &newWorkingDirectory = workingDirectory();
182 if (oldWorkingDirectory != newWorkingDirectory)
183 emit baseWorkingDirectoryChanged(newWorkingDirectory);
186 QVariantMap CMakeRunConfiguration::toMap() const
188 QVariantMap map(ProjectExplorer::LocalApplicationRunConfiguration::toMap());
190 map.insert(QLatin1String(USER_WORKING_DIRECTORY_KEY), m_userWorkingDirectory);
191 map.insert(QLatin1String(USE_TERMINAL_KEY), m_runMode == Console);
192 map.insert(QLatin1String(TITLE_KEY), m_title);
193 map.insert(QLatin1String(ARGUMENTS_KEY), m_arguments);
194 map.insert(QLatin1String(USER_ENVIRONMENT_CHANGES_KEY), Utils::EnvironmentItem::toStringList(m_userEnvironmentChanges));
195 map.insert(QLatin1String(BASE_ENVIRONMENT_BASE_KEY), m_baseEnvironmentBase);
200 bool CMakeRunConfiguration::fromMap(const QVariantMap &map)
202 m_userWorkingDirectory = map.value(QLatin1String(USER_WORKING_DIRECTORY_KEY)).toString();
203 m_runMode = map.value(QLatin1String(USE_TERMINAL_KEY)).toBool() ? Console : Gui;
204 m_title = map.value(QLatin1String(TITLE_KEY)).toString();
205 m_arguments = map.value(QLatin1String(ARGUMENTS_KEY)).toString();
206 m_userEnvironmentChanges = Utils::EnvironmentItem::fromStringList(map.value(QLatin1String(USER_ENVIRONMENT_CHANGES_KEY)).toStringList());
207 m_baseEnvironmentBase = static_cast<BaseEnvironmentBase>(map.value(QLatin1String(BASE_ENVIRONMENT_BASE_KEY), static_cast<int>(CMakeRunConfiguration::BuildEnvironmentBase)).toInt());
209 return RunConfiguration::fromMap(map);
212 QString CMakeRunConfiguration::defaultDisplayName() const
214 if (m_title.isEmpty())
215 return tr("Run CMake target");
216 return m_title + (m_enabled ? "" : tr(" (disabled)"));
219 QWidget *CMakeRunConfiguration::createConfigurationWidget()
221 return new CMakeRunConfigurationWidget(this);
224 void CMakeRunConfiguration::setCommandLineArguments(const QString &newText)
226 m_arguments = newText;
229 QString CMakeRunConfiguration::dumperLibrary() const
231 QString qmakePath = ProjectExplorer::DebuggingHelperLibrary::findSystemQt(environment());
232 QString qtInstallData = ProjectExplorer::DebuggingHelperLibrary::qtInstallDataDir(qmakePath);
233 QString dhl = ProjectExplorer::DebuggingHelperLibrary::debuggingHelperLibraryByInstallData(qtInstallData);
237 QStringList CMakeRunConfiguration::dumperLibraryLocations() const
239 QString qmakePath = ProjectExplorer::DebuggingHelperLibrary::findSystemQt(environment());
240 QString qtInstallData = ProjectExplorer::DebuggingHelperLibrary::qtInstallDataDir(qmakePath);
241 return ProjectExplorer::DebuggingHelperLibrary::locationsByInstallData(qtInstallData);
244 Utils::Environment CMakeRunConfiguration::baseEnvironment() const
246 Utils::Environment env;
247 if (m_baseEnvironmentBase == CMakeRunConfiguration::CleanEnvironmentBase) {
249 } else if (m_baseEnvironmentBase == CMakeRunConfiguration::SystemEnvironmentBase) {
250 env = Utils::Environment::systemEnvironment();
251 } else if (m_baseEnvironmentBase == CMakeRunConfiguration::BuildEnvironmentBase) {
252 env = activeBuildConfiguration()->environment();
257 QString CMakeRunConfiguration::baseEnvironmentText() const
259 if (m_baseEnvironmentBase == CMakeRunConfiguration::CleanEnvironmentBase) {
260 return tr("Clean Environment");
261 } else if (m_baseEnvironmentBase == CMakeRunConfiguration::SystemEnvironmentBase) {
262 return tr("System Environment");
263 } else if (m_baseEnvironmentBase == CMakeRunConfiguration::BuildEnvironmentBase) {
264 return tr("Build Environment");
269 void CMakeRunConfiguration::setBaseEnvironmentBase(BaseEnvironmentBase env)
271 if (m_baseEnvironmentBase == env)
273 m_baseEnvironmentBase = env;
274 emit baseEnvironmentChanged();
277 CMakeRunConfiguration::BaseEnvironmentBase CMakeRunConfiguration::baseEnvironmentBase() const
279 return m_baseEnvironmentBase;
282 Utils::Environment CMakeRunConfiguration::environment() const
284 Utils::Environment env = baseEnvironment();
285 env.modify(userEnvironmentChanges());
289 QList<Utils::EnvironmentItem> CMakeRunConfiguration::userEnvironmentChanges() const
291 return m_userEnvironmentChanges;
294 void CMakeRunConfiguration::setUserEnvironmentChanges(const QList<Utils::EnvironmentItem> &diff)
296 if (m_userEnvironmentChanges != diff) {
297 m_userEnvironmentChanges = diff;
298 emit userEnvironmentChangesChanged(diff);
302 ProjectExplorer::ToolChainType CMakeRunConfiguration::toolChainType() const
304 CMakeBuildConfiguration *bc = activeBuildConfiguration();
306 return ProjectExplorer::ToolChain_UNKNOWN;
307 return bc->toolChainType();
310 void CMakeRunConfiguration::setEnabled(bool b)
315 emit isEnabledChanged(isEnabled());
316 setDefaultDisplayName(defaultDisplayName());
319 bool CMakeRunConfiguration::isEnabled(ProjectExplorer::BuildConfiguration *bc) const
321 return m_enabled && LocalApplicationRunConfiguration::isEnabled(bc);
324 // Configuration widget
325 CMakeRunConfigurationWidget::CMakeRunConfigurationWidget(CMakeRunConfiguration *cmakeRunConfiguration, QWidget *parent)
326 : QWidget(parent), m_ignoreChange(false), m_cmakeRunConfiguration(cmakeRunConfiguration)
328 QFormLayout *fl = new QFormLayout();
330 fl->setFieldGrowthPolicy(QFormLayout::ExpandingFieldsGrow);
331 QLineEdit *argumentsLineEdit = new QLineEdit();
332 argumentsLineEdit->setText(cmakeRunConfiguration->commandLineArguments());
333 connect(argumentsLineEdit, SIGNAL(textChanged(QString)),
334 this, SLOT(setArguments(QString)));
335 fl->addRow(tr("Arguments:"), argumentsLineEdit);
337 m_workingDirectoryEdit = new Utils::PathChooser();
338 m_workingDirectoryEdit->setBaseDirectory(m_cmakeRunConfiguration->target()->project()->projectDirectory());
339 m_workingDirectoryEdit->setPath(m_cmakeRunConfiguration->baseWorkingDirectory());
340 m_workingDirectoryEdit->setExpectedKind(Utils::PathChooser::Directory);
341 m_workingDirectoryEdit->setPromptDialogTitle(tr("Select Working Directory"));
343 QToolButton *resetButton = new QToolButton();
344 resetButton->setToolTip(tr("Reset to default"));
345 resetButton->setIcon(QIcon(QLatin1String(Core::Constants::ICON_RESET)));
347 QHBoxLayout *boxlayout = new QHBoxLayout();
348 boxlayout->addWidget(m_workingDirectoryEdit);
349 boxlayout->addWidget(resetButton);
351 fl->addRow(tr("Working directory:"), boxlayout);
353 QWidget *debuggerLabelWidget = new QWidget(this);
354 QVBoxLayout *debuggerLabelLayout = new QVBoxLayout(debuggerLabelWidget);
355 debuggerLabelLayout->setMargin(0);
356 debuggerLabelLayout->setSpacing(0);
357 debuggerLabelWidget->setLayout(debuggerLabelLayout);
358 QLabel *debuggerLabel = new QLabel(tr("Debugger:"), this);
359 debuggerLabelLayout->addWidget(debuggerLabel);
360 debuggerLabelLayout->addStretch(10);
362 m_debuggerLanguageChooser = new Utils::DebuggerLanguageChooser(this);
363 fl->addRow(debuggerLabelWidget, m_debuggerLanguageChooser);
365 m_debuggerLanguageChooser->setCppChecked(m_cmakeRunConfiguration->useCppDebugger());
366 m_debuggerLanguageChooser->setQmlChecked(m_cmakeRunConfiguration->useQmlDebugger());
367 m_debuggerLanguageChooser->setQmlDebugServerPort(m_cmakeRunConfiguration->qmlDebugServerPort());
369 m_detailsContainer = new Utils::DetailsWidget(this);
370 m_detailsContainer->setState(Utils::DetailsWidget::NoSummary);
372 QWidget *m_details = new QWidget(m_detailsContainer);
373 m_detailsContainer->setWidget(m_details);
374 m_details->setLayout(fl);
376 QVBoxLayout *vbx = new QVBoxLayout(this);
378 vbx->addWidget(m_detailsContainer);
380 QLabel *environmentLabel = new QLabel(this);
381 environmentLabel->setText(tr("Run Environment"));
382 QFont f = environmentLabel->font();
384 f.setPointSizeF(f.pointSizeF() *1.2);
385 environmentLabel->setFont(f);
386 vbx->addWidget(environmentLabel);
388 QWidget *baseEnvironmentWidget = new QWidget;
389 QHBoxLayout *baseEnvironmentLayout = new QHBoxLayout(baseEnvironmentWidget);
390 baseEnvironmentLayout->setMargin(0);
391 QLabel *label = new QLabel(tr("Base environment for this runconfiguration:"), this);
392 baseEnvironmentLayout->addWidget(label);
393 m_baseEnvironmentComboBox = new QComboBox(this);
394 m_baseEnvironmentComboBox->addItems(QStringList()
395 << tr("Clean Environment")
396 << tr("System Environment")
397 << tr("Build Environment"));
398 m_baseEnvironmentComboBox->setCurrentIndex(m_cmakeRunConfiguration->baseEnvironmentBase());
399 connect(m_baseEnvironmentComboBox, SIGNAL(currentIndexChanged(int)),
400 this, SLOT(baseEnvironmentComboBoxChanged(int)));
401 baseEnvironmentLayout->addWidget(m_baseEnvironmentComboBox);
402 baseEnvironmentLayout->addStretch(10);
404 m_environmentWidget = new ProjectExplorer::EnvironmentWidget(this, baseEnvironmentWidget);
405 m_environmentWidget->setBaseEnvironment(m_cmakeRunConfiguration->baseEnvironment());
406 m_environmentWidget->setBaseEnvironmentText(m_cmakeRunConfiguration->baseEnvironmentText());
407 m_environmentWidget->setUserChanges(m_cmakeRunConfiguration->userEnvironmentChanges());
409 vbx->addWidget(m_environmentWidget);
411 connect(m_workingDirectoryEdit, SIGNAL(changed(QString)),
412 this, SLOT(setWorkingDirectory()));
414 connect(resetButton, SIGNAL(clicked()),
415 this, SLOT(resetWorkingDirectory()));
417 connect(m_debuggerLanguageChooser, SIGNAL(cppLanguageToggled(bool)),
418 this, SLOT(useCppDebuggerToggled(bool)));
419 connect(m_debuggerLanguageChooser, SIGNAL(qmlLanguageToggled(bool)),
420 this, SLOT(useQmlDebuggerToggled(bool)));
421 connect(m_debuggerLanguageChooser, SIGNAL(qmlDebugServerPortChanged(uint)),
422 this, SLOT(qmlDebugServerPortChanged(uint)));
424 connect(m_environmentWidget, SIGNAL(userChangesChanged()),
425 this, SLOT(userChangesChanged()));
427 connect(m_cmakeRunConfiguration, SIGNAL(baseWorkingDirectoryChanged(QString)),
428 this, SLOT(workingDirectoryChanged(QString)));
429 connect(m_cmakeRunConfiguration, SIGNAL(baseEnvironmentChanged()),
430 this, SLOT(baseEnvironmentChanged()));
431 connect(m_cmakeRunConfiguration, SIGNAL(userEnvironmentChangesChanged(QList<Utils::EnvironmentItem>)),
432 this, SLOT(userEnvironmentChangesChanged()));
434 setEnabled(m_cmakeRunConfiguration->isEnabled());
437 void CMakeRunConfigurationWidget::setWorkingDirectory()
441 m_ignoreChange = true;
442 m_cmakeRunConfiguration->setUserWorkingDirectory(m_workingDirectoryEdit->rawPath());
443 m_ignoreChange = false;
446 void CMakeRunConfigurationWidget::workingDirectoryChanged(const QString &workingDirectory)
449 m_workingDirectoryEdit->setPath(workingDirectory);
452 void CMakeRunConfigurationWidget::resetWorkingDirectory()
454 // This emits a signal connected to workingDirectoryChanged()
455 // that sets the m_workingDirectoryEdit
456 m_cmakeRunConfiguration->setUserWorkingDirectory(QString());
459 void CMakeRunConfigurationWidget::useCppDebuggerToggled(bool toggled)
461 m_cmakeRunConfiguration->setUseCppDebugger(toggled);
464 void CMakeRunConfigurationWidget::useQmlDebuggerToggled(bool toggled)
466 m_cmakeRunConfiguration->setUseQmlDebugger(toggled);
469 void CMakeRunConfigurationWidget::qmlDebugServerPortChanged(uint port)
471 m_cmakeRunConfiguration->setQmlDebugServerPort(port);
474 void CMakeRunConfigurationWidget::userChangesChanged()
476 m_cmakeRunConfiguration->setUserEnvironmentChanges(m_environmentWidget->userChanges());
479 void CMakeRunConfigurationWidget::baseEnvironmentComboBoxChanged(int index)
481 m_ignoreChange = true;
482 m_cmakeRunConfiguration->setBaseEnvironmentBase(CMakeRunConfiguration::BaseEnvironmentBase(index));
484 m_environmentWidget->setBaseEnvironment(m_cmakeRunConfiguration->baseEnvironment());
485 m_environmentWidget->setBaseEnvironmentText(m_cmakeRunConfiguration->baseEnvironmentText());
486 m_ignoreChange = false;
489 void CMakeRunConfigurationWidget::baseEnvironmentChanged()
494 m_baseEnvironmentComboBox->setCurrentIndex(m_cmakeRunConfiguration->baseEnvironmentBase());
495 m_environmentWidget->setBaseEnvironment(m_cmakeRunConfiguration->baseEnvironment());
496 m_environmentWidget->setBaseEnvironmentText(m_cmakeRunConfiguration->baseEnvironmentText());
499 void CMakeRunConfigurationWidget::userEnvironmentChangesChanged()
501 m_environmentWidget->setUserChanges(m_cmakeRunConfiguration->userEnvironmentChanges());
504 void CMakeRunConfigurationWidget::setArguments(const QString &args)
506 m_cmakeRunConfiguration->setCommandLineArguments(args);
510 CMakeRunConfigurationFactory::CMakeRunConfigurationFactory(QObject *parent) :
511 ProjectExplorer::IRunConfigurationFactory(parent)
515 CMakeRunConfigurationFactory::~CMakeRunConfigurationFactory()
519 // used to show the list of possible additons to a project, returns a list of ids
520 QStringList CMakeRunConfigurationFactory::availableCreationIds(ProjectExplorer::Target *parent) const
522 CMakeTarget *t(qobject_cast<CMakeTarget *>(parent));
524 return QStringList();
526 foreach (const QString &buildTarget, t->cmakeProject()->buildTargetTitles())
527 allIds << idFromBuildTarget(buildTarget);
531 // used to translate the ids to names to display to the user
532 QString CMakeRunConfigurationFactory::displayNameForId(const QString &id) const
534 return buildTargetFromId(id);
537 bool CMakeRunConfigurationFactory::canCreate(ProjectExplorer::Target *parent, const QString &id) const
539 CMakeTarget *t(qobject_cast<CMakeTarget *>(parent));
542 return t->cmakeProject()->hasBuildTarget(buildTargetFromId(id));
545 ProjectExplorer::RunConfiguration *CMakeRunConfigurationFactory::create(ProjectExplorer::Target *parent, const QString &id)
547 if (!canCreate(parent, id))
549 CMakeTarget *t(static_cast<CMakeTarget *>(parent));
551 const QString title(buildTargetFromId(id));
552 const CMakeBuildTarget &ct = t->cmakeProject()->buildTargetForTitle(title);
553 return new CMakeRunConfiguration(t, ct.executable, ct.workingDirectory, ct.title);
556 bool CMakeRunConfigurationFactory::canClone(ProjectExplorer::Target *parent, ProjectExplorer::RunConfiguration *source) const
558 if (!qobject_cast<CMakeTarget *>(parent))
560 return source->id() == QLatin1String(CMAKE_RC_ID);
563 ProjectExplorer::RunConfiguration *CMakeRunConfigurationFactory::clone(ProjectExplorer::Target *parent, ProjectExplorer::RunConfiguration * source)
565 if (!canClone(parent, source))
567 CMakeTarget *t(static_cast<CMakeTarget *>(parent));
568 CMakeRunConfiguration *crc(static_cast<CMakeRunConfiguration *>(source));
569 return new CMakeRunConfiguration(t, crc);
572 bool CMakeRunConfigurationFactory::canRestore(ProjectExplorer::Target *parent, const QVariantMap &map) const
574 if (!qobject_cast<CMakeTarget *>(parent))
576 QString id(ProjectExplorer::idFromMap(map));
577 return id.startsWith(QLatin1String(CMAKE_RC_ID));
580 ProjectExplorer::RunConfiguration *CMakeRunConfigurationFactory::restore(ProjectExplorer::Target *parent, const QVariantMap &map)
582 if (!canRestore(parent, map))
584 CMakeTarget *t(static_cast<CMakeTarget *>(parent));
585 CMakeRunConfiguration *rc(new CMakeRunConfiguration(t, QString(), QString(), QString()));
586 if (rc->fromMap(map))