{
QStringList args;
args << QLatin1String("whoami")
- << QString("%1 <%2>").arg(settings()->userName()).arg(settings()->email());
+ << QString("%1 <%2>")
+ .arg(settings()->stringValue(BazaarSettings::userNameKey))
+ .arg(settings()->stringValue(BazaarSettings::userEmailKey));
QByteArray stdOut;
return vcsFullySynchronousExec(QDir::currentPath(), args, &stdOut);
}
VCSBase::VCSBaseEditorParameterWidget(parent), m_client(client), m_params(p)
{
mapSetting(addToggleButton(QLatin1String("-w"), tr("Ignore whitespace")),
- &client->settings()->diffIgnoreWhiteSpace);
+ client->settings()->boolPointer(BazaarSettings::diffIgnoreWhiteSpaceKey));
mapSetting(addToggleButton(QLatin1String("-B"), tr("Ignore blank lines")),
- &client->settings()->diffIgnoreBlankLines);
+ client->settings()->boolPointer(BazaarSettings::diffIgnoreBlankLinesKey));
}
QStringList arguments() const
{
mapSetting(addToggleButton(QLatin1String("--verbose"), tr("Verbose"),
tr("Show files changed in each revision")),
- &m_client->settings()->logVerbose);
+ m_client->settings()->boolPointer(BazaarSettings::logVerboseKey));
mapSetting(addToggleButton(QLatin1String("--forward"), tr("Forward"),
tr("Show from oldest to newest")),
- &m_client->settings()->logForward);
+ m_client->settings()->boolPointer(BazaarSettings::logForwardKey));
mapSetting(addToggleButton(QLatin1String("--include-merges"), tr("Include merges"),
tr("Show merged revisions")),
- &m_client->settings()->logIncludeMerges);
+ m_client->settings()->boolPointer(BazaarSettings::logIncludeMergesKey));
QList<ComboBoxItem> logChoices;
logChoices << ComboBoxItem(tr("Detailed"), QLatin1String("long"))
<< ComboBoxItem(tr("One line"), QLatin1String("line"))
<< ComboBoxItem(tr("GNU ChangeLog"), QLatin1String("gnu-changelog"));
mapSetting(addComboBox(QLatin1String("--log-format"), logChoices),
- &m_client->settings()->logFormat);
+ m_client->settings()->stringPointer(BazaarSettings::logFormatKey));
}
void executeCommand()
bool BazaarControl::isConfigured() const
{
- const QString binary = m_bazaarClient->settings()->binary();
+ const QString binary = m_bazaarClient->settings()->stringValue(BazaarSettings::binaryPathKey);
if (binary.isEmpty())
return false;
QFileInfo fi(binary);
const VCSBase::VCSBasePluginState state = currentState();
QTC_ASSERT(state.hasTopLevel(), return);
QStringList extraOptions;
- extraOptions += QString("--limit=%1").arg(settings().logCount());
+ extraOptions += QString("--limit=%1").arg(settings().intValue(BazaarSettings::logCountKey));
m_client->log(state.topLevel(), QStringList(), extraOptions);
}
commitEditor->setDisplayName(msg);
const BranchInfo branch = m_client->synchronousBranchQuery(m_submitRepository);
- commitEditor->setFields(branch, m_bazaarSettings.userName(),
- m_bazaarSettings.email(), status);
+ commitEditor->setFields(branch, m_bazaarSettings.stringValue(BazaarSettings::userNameKey),
+ m_bazaarSettings.stringValue(BazaarSettings::userEmailKey), status);
commitEditor->registerActions(m_editorUndo, m_editorRedo, m_editorCommit, m_editorDiff);
connect(commitEditor, SIGNAL(diffSelectedFiles(QStringList)),
if (!editorFile || !commitEditor)
return true;
- bool dummyPrompt = m_bazaarSettings.prompt();
+ bool dummyPrompt = m_bazaarSettings.boolValue(BazaarSettings::promptOnSubmitKey);
const VCSBase::VCSBaseSubmitEditor::PromptSubmitResult response =
commitEditor->promptSubmit(tr("Close Commit Editor"), tr("Do you want to commit the changes?"),
tr("Message check failed. Do you want to proceed?"),
- &dummyPrompt, m_bazaarSettings.prompt());
+ &dummyPrompt, dummyPrompt);
switch (response) {
case VCSBase::VCSBaseSubmitEditor::SubmitCanceled:
namespace Bazaar {
namespace Internal {
-const QLatin1String diffIgnoreWhiteSpaceKey("diffIgnoreWhiteSpace");
-const QLatin1String diffIgnoreBlankLinesKey("diffIgnoreBlankLines");
-const QLatin1String logVerboseKey("logVerbose");
-const QLatin1String logForwardKey("logForward");
-const QLatin1String logIncludeMergesKey("logIncludeMerges");
-const QLatin1String logFormatKey("logFormat");
+const QLatin1String BazaarSettings::diffIgnoreWhiteSpaceKey("diffIgnoreWhiteSpace");
+const QLatin1String BazaarSettings::diffIgnoreBlankLinesKey("diffIgnoreBlankLines");
+const QLatin1String BazaarSettings::logVerboseKey("logVerbose");
+const QLatin1String BazaarSettings::logForwardKey("logForward");
+const QLatin1String BazaarSettings::logIncludeMergesKey("logIncludeMerges");
+const QLatin1String BazaarSettings::logFormatKey("logFormat");
-BazaarSettings::BazaarSettings() :
- diffIgnoreWhiteSpace(false),
- diffIgnoreBlankLines(false),
- logVerbose(false),
- logForward(false),
- logIncludeMerges(false),
- logFormat(QLatin1String("long"))
+BazaarSettings::BazaarSettings()
{
setSettingsGroup(QLatin1String(Constants::BAZAAR));
- setDefaultBinary(QLatin1String(Constants::BAZAARDEFAULT));
-}
-
-BazaarSettings& BazaarSettings::operator=(const BazaarSettings& other)
-{
- VCSBase::VCSBaseClientSettings::operator=(other);
- if (this != &other) {
- diffIgnoreWhiteSpace = other.diffIgnoreWhiteSpace;
- diffIgnoreBlankLines = other.diffIgnoreBlankLines;
- logVerbose = other.logVerbose;
- logForward = other.logForward;
- logIncludeMerges = other.logIncludeMerges;
- logFormat = other.logFormat;
- }
- return *this;
+ // Override default binary path
+ declareKey(binaryPathKey, QLatin1String(Constants::BAZAARDEFAULT));
+ declareKey(diffIgnoreWhiteSpaceKey, false);
+ declareKey(diffIgnoreBlankLinesKey, false);
+ declareKey(logVerboseKey, false);
+ declareKey(logForwardKey, false);
+ declareKey(logIncludeMergesKey, false);
+ declareKey(logFormatKey, QLatin1String("long"));
}
bool BazaarSettings::sameUserId(const BazaarSettings& other) const
{
- return userName() == other.userName() && email() == other.email();
-}
-
-void BazaarSettings::writeSettings(QSettings *settings) const
-{
- VCSBaseClientSettings::writeSettings(settings);
- settings->beginGroup(settingsGroup());
- settings->setValue(diffIgnoreWhiteSpaceKey, diffIgnoreWhiteSpace);
- settings->setValue(diffIgnoreBlankLinesKey, diffIgnoreBlankLines);
- settings->setValue(logVerboseKey, logVerbose);
- settings->setValue(logForwardKey, logForward);
- settings->setValue(logIncludeMergesKey, logIncludeMerges);
- settings->setValue(logFormatKey, logFormat);
- settings->endGroup();
-}
-
-void BazaarSettings::readSettings(const QSettings *settings)
-{
- VCSBaseClientSettings::readSettings(settings);
- const QString keyRoot = settingsGroup() + QLatin1Char('/');
- diffIgnoreWhiteSpace = settings->value(keyRoot + diffIgnoreWhiteSpaceKey, false).toBool();
- diffIgnoreBlankLines = settings->value(keyRoot + diffIgnoreBlankLinesKey, false).toBool();
- logVerbose = settings->value(keyRoot + logVerboseKey, false).toBool();
- logForward = settings->value(keyRoot + logForwardKey, false).toBool();
- logIncludeMerges = settings->value(keyRoot + logIncludeMergesKey, false).toBool();
- logFormat = settings->value(keyRoot + logFormatKey, QLatin1String("long")).toString();
-}
-
-bool BazaarSettings::equals(const VCSBaseClientSettings &rhs) const
-{
- const BazaarSettings *bzrRhs = dynamic_cast<const BazaarSettings *>(&rhs);
- if (bzrRhs == 0)
- return false;
- return VCSBaseClientSettings::equals(rhs)
- && diffIgnoreWhiteSpace == bzrRhs->diffIgnoreWhiteSpace
- && diffIgnoreBlankLines == bzrRhs->diffIgnoreBlankLines
- && logVerbose == bzrRhs->logVerbose
- && logForward == bzrRhs->logForward
- && logIncludeMerges == bzrRhs->logIncludeMerges
- && logFormat == bzrRhs->logFormat;
+ return stringValue(userNameKey) == other.stringValue(userNameKey) &&
+ stringValue(userEmailKey) == other.stringValue(userEmailKey);
}
} // namespace Internal
class BazaarSettings : public VCSBase::VCSBaseClientSettings
{
public:
+ static const QLatin1String diffIgnoreWhiteSpaceKey;
+ static const QLatin1String diffIgnoreBlankLinesKey;
+ static const QLatin1String logVerboseKey;
+ static const QLatin1String logForwardKey;
+ static const QLatin1String logIncludeMergesKey;
+ static const QLatin1String logFormatKey;
+
BazaarSettings();
- BazaarSettings& operator=(const BazaarSettings& other);
bool sameUserId(const BazaarSettings& other) const;
-
- virtual void writeSettings(QSettings *settings) const;
- virtual void readSettings(const QSettings *settings);
- virtual bool equals(const VCSBaseClientSettings &rhs) const;
-
- bool diffIgnoreWhiteSpace;
- bool diffIgnoreBlankLines;
-
- bool logVerbose;
- bool logForward;
- bool logIncludeMerges;
- QString logFormat;
};
} // namespace Internal
return QSharedPointer<VCSBase::AbstractCheckoutJob>();
const BazaarSettings &settings = BazaarPlugin::instance()->settings();
- QStringList args = settings.standardArguments();
*checkoutPath = page->path() + QLatin1Char('/') + page->directory();
const CloneOptionsPanel *panel = page->cloneOptionsPanel();
if (!panel->revision().isEmpty())
extraOptions << QLatin1String("-r") << panel->revision();
const BazaarClient *client = BazaarPlugin::instance()->client();
+ QStringList args;
args << client->vcsCommandString(BazaarClient::CloneCommand)
<< extraOptions << page->repository() << page->directory();
VCSBase::ProcessCheckoutJob *job = new VCSBase::ProcessCheckoutJob;
- job->addStep(settings.binary(), args, page->path());
+ job->addStep(settings.stringValue(BazaarSettings::binaryPathKey), args, page->path());
return QSharedPointer<VCSBase::AbstractCheckoutJob>(job);
}
BazaarSettings OptionsPageWidget::settings() const
{
- BazaarSettings rc;
- rc.setBinary(m_ui.commandChooser->path());
- rc.setUserName(m_ui.defaultUsernameLineEdit->text().trimmed());
- rc.setEmail(m_ui.defaultEmailLineEdit->text().trimmed());
- rc.setLogCount(m_ui.logEntriesCount->value());
- rc.setTimeoutSeconds(m_ui.timeout->value());
- rc.setPrompt(m_ui.promptOnSubmitCheckBox->isChecked());
- return rc;
+ BazaarSettings s = BazaarPlugin::instance()->settings();
+ s.setValue(BazaarSettings::binaryPathKey, m_ui.commandChooser->path());
+ s.setValue(BazaarSettings::userNameKey, m_ui.defaultUsernameLineEdit->text().trimmed());
+ s.setValue(BazaarSettings::userEmailKey, m_ui.defaultEmailLineEdit->text().trimmed());
+ s.setValue(BazaarSettings::logCountKey, m_ui.logEntriesCount->value());
+ s.setValue(BazaarSettings::timeoutKey, m_ui.timeout->value());
+ s.setValue(BazaarSettings::promptOnSubmitKey, m_ui.promptOnSubmitCheckBox->isChecked());
+ return s;
}
void OptionsPageWidget::setSettings(const BazaarSettings &s)
{
- m_ui.commandChooser->setPath(s.binary());
- m_ui.defaultUsernameLineEdit->setText(s.userName());
- m_ui.defaultEmailLineEdit->setText(s.email());
- m_ui.logEntriesCount->setValue(s.logCount());
- m_ui.timeout->setValue(s.timeoutSeconds());
- m_ui.promptOnSubmitCheckBox->setChecked(s.prompt());
+ m_ui.commandChooser->setPath(s.stringValue(BazaarSettings::binaryPathKey));
+ m_ui.defaultUsernameLineEdit->setText(s.stringValue(BazaarSettings::userNameKey));
+ m_ui.defaultEmailLineEdit->setText(s.stringValue(BazaarSettings::userEmailKey));
+ m_ui.logEntriesCount->setValue(s.intValue(BazaarSettings::logCountKey));
+ m_ui.timeout->setValue(s.intValue(BazaarSettings::timeoutKey));
+ m_ui.promptOnSubmitCheckBox->setChecked(s.boolValue(BazaarSettings::promptOnSubmitKey));
}
QString OptionsPageWidget::searchKeywords() const
const MercurialSettings &settings = MercurialPlugin::instance()->settings();
- QStringList args = settings.standardArguments();
QString path = page->path();
QString directory = page->directory();
+ QStringList args;
args << QLatin1String("clone") << page->repository() << directory;
*checkoutPath = path + QLatin1Char('/') + directory;
VCSBase::ProcessCheckoutJob *job = new VCSBase::ProcessCheckoutJob;
- job->addStep(settings.binary(), args, path);
+ job->addStep(settings.stringValue(MercurialSettings::binaryPathKey), args, path);
return QSharedPointer<VCSBase::AbstractCheckoutJob>(job);
}
VCSBase::VCSBaseEditorParameterWidget(parent), m_client(client), m_params(p)
{
mapSetting(addToggleButton(QLatin1String("-w"), tr("Ignore whitespace")),
- &client->settings()->diffIgnoreWhiteSpace);
+ client->settings()->boolPointer(MercurialSettings::diffIgnoreWhiteSpaceKey));
mapSetting(addToggleButton(QLatin1String("-B"), tr("Ignore blank lines")),
- &client->settings()->diffIgnoreBlankLines);
+ client->settings()->boolPointer(MercurialSettings::diffIgnoreBlankLinesKey));
}
void executeCommand()
bool MercurialControl::isConfigured() const
{
- const QString binary = mercurialClient->settings()->binary();
+ const QString binary = mercurialClient->settings()->stringValue(MercurialSettings::binaryPathKey);
if (binary.isEmpty())
return false;
QFileInfo fi(binary);
}
}
-QStringList MercurialPlugin::standardArguments() const
-{
- return mercurialSettings.standardArguments();
-}
-
void MercurialPlugin::createMenu()
{
Core::Context context(Core::Constants::C_GLOBAL);
QString branch = m_client->branchQuerySync(m_submitRepository);
- commitEditor->setFields(m_submitRepository, branch, mercurialSettings.userName(),
- mercurialSettings.email(), status);
+ commitEditor->setFields(m_submitRepository, branch,
+ mercurialSettings.stringValue(MercurialSettings::userNameKey),
+ mercurialSettings.stringValue(MercurialSettings::userEmailKey), status);
commitEditor->registerActions(editorUndo, editorRedo, editorCommit, editorDiff);
connect(commitEditor, SIGNAL(diffSelectedFiles(QStringList)),
if (!editorFile || !commitEditor)
return true;
- bool dummyPrompt = mercurialSettings.prompt();
+ bool dummyPrompt = mercurialSettings.boolValue(MercurialSettings::promptOnSubmitKey);
const VCSBase::VCSBaseSubmitEditor::PromptSubmitResult response =
commitEditor->promptSubmit(tr("Close Commit Editor"), tr("Do you want to commit the changes?"),
tr("Message check failed. Do you want to proceed?"),
- &dummyPrompt, mercurialSettings.prompt());
+ &dummyPrompt, dummyPrompt);
switch (response) {
case VCSBase::VCSBaseSubmitEditor::SubmitCanceled:
static MercurialPlugin *instance() { return m_instance; }
MercurialClient *client() const { return m_client; }
- QStringList standardArguments() const;
-
const MercurialSettings &settings() const;
void setSettings(const MercurialSettings &settings);
namespace Mercurial {
namespace Internal {
- const QLatin1String diffIgnoreWhiteSpaceKey("diffIgnoreWhiteSpace");
- const QLatin1String diffIgnoreBlankLinesKey("diffIgnoreBlankLines");
+ const QLatin1String MercurialSettings::diffIgnoreWhiteSpaceKey("diffIgnoreWhiteSpace");
+ const QLatin1String MercurialSettings::diffIgnoreBlankLinesKey("diffIgnoreBlankLines");
- MercurialSettings::MercurialSettings() :
- diffIgnoreWhiteSpace(false),
- diffIgnoreBlankLines(false)
+ MercurialSettings::MercurialSettings()
{
setSettingsGroup(QLatin1String("Mercurial"));
- setDefaultBinary(QLatin1String(Constants::MERCURIALDEFAULT));
+ // Override default binary path
+ declareKey(binaryPathKey, QLatin1String(Constants::MERCURIALDEFAULT));
+ declareKey(diffIgnoreWhiteSpaceKey, false);
+ declareKey(diffIgnoreBlankLinesKey, false);
}
-
- MercurialSettings& MercurialSettings::operator=(const MercurialSettings& other)
- {
- VCSBase::VCSBaseClientSettings::operator=(other);
- if (this != &other) {
- diffIgnoreWhiteSpace = other.diffIgnoreWhiteSpace;
- diffIgnoreBlankLines = other.diffIgnoreBlankLines;
- }
- return *this;
- }
-
- void MercurialSettings::writeSettings(QSettings *settings) const
- {
- VCSBaseClientSettings::writeSettings(settings);
- settings->beginGroup(this->settingsGroup());
- settings->setValue(diffIgnoreWhiteSpaceKey, diffIgnoreWhiteSpace);
- settings->setValue(diffIgnoreBlankLinesKey, diffIgnoreBlankLines);
- settings->endGroup();
- }
-
- void MercurialSettings::readSettings(const QSettings *settings)
- {
- VCSBaseClientSettings::readSettings(settings);
- const QString keyRoot = this->settingsGroup() + QLatin1Char('/');
- diffIgnoreWhiteSpace = settings->value(keyRoot + diffIgnoreWhiteSpaceKey, false).toBool();
- diffIgnoreBlankLines = settings->value(keyRoot + diffIgnoreBlankLinesKey, false).toBool();
- }
-
- bool MercurialSettings::equals(const VCSBaseClientSettings &rhs) const
- {
- const MercurialSettings *hgRhs = dynamic_cast<const MercurialSettings *>(&rhs);
- if (hgRhs == 0)
- return false;
- return VCSBaseClientSettings::equals(rhs)
- && diffIgnoreWhiteSpace == hgRhs->diffIgnoreWhiteSpace
- && diffIgnoreBlankLines == hgRhs->diffIgnoreBlankLines;
- }
-
} // namespace Internal
} // namespace Mercurial
class MercurialSettings : public VCSBase::VCSBaseClientSettings
{
public:
- MercurialSettings();
- MercurialSettings& operator=(const MercurialSettings& other);
-
- virtual void writeSettings(QSettings *settings) const;
- virtual void readSettings(const QSettings *settings);
- virtual bool equals(const VCSBaseClientSettings &rhs) const;
+ static const QLatin1String diffIgnoreWhiteSpaceKey;
+ static const QLatin1String diffIgnoreBlankLinesKey;
- bool diffIgnoreWhiteSpace;
- bool diffIgnoreBlankLines;
+ MercurialSettings();
};
} // namespace Internal
MercurialSettings OptionsPageWidget::settings() const
{
- MercurialSettings rc;
- rc.setBinary(m_ui.commandChooser->path());
- rc.setUserName(m_ui.defaultUsernameLineEdit->text().trimmed());
- rc.setEmail(m_ui.defaultEmailLineEdit->text().trimmed());
- rc.setLogCount(m_ui.logEntriesCount->value());
- rc.setTimeoutSeconds(m_ui.timeout->value());
- rc.setPrompt(m_ui.promptOnSubmitCheckBox->isChecked());
- return rc;
+ MercurialSettings s = MercurialPlugin::instance()->settings();
+ s.setValue(MercurialSettings::binaryPathKey, m_ui.commandChooser->path());
+ s.setValue(MercurialSettings::userNameKey, m_ui.defaultUsernameLineEdit->text().trimmed());
+ s.setValue(MercurialSettings::userEmailKey, m_ui.defaultEmailLineEdit->text().trimmed());
+ s.setValue(MercurialSettings::logCountKey, m_ui.logEntriesCount->value());
+ s.setValue(MercurialSettings::timeoutKey, m_ui.timeout->value());
+ s.setValue(MercurialSettings::promptOnSubmitKey, m_ui.promptOnSubmitCheckBox->isChecked());
+ return s;
}
void OptionsPageWidget::setSettings(const MercurialSettings &s)
{
- m_ui.commandChooser->setPath(s.binary());
- m_ui.defaultUsernameLineEdit->setText(s.userName());
- m_ui.defaultEmailLineEdit->setText(s.email());
- m_ui.logEntriesCount->setValue(s.logCount());
- m_ui.timeout->setValue(s.timeoutSeconds());
- m_ui.promptOnSubmitCheckBox->setChecked(s.prompt());
+ m_ui.commandChooser->setPath(s.stringValue(MercurialSettings::binaryPathKey));
+ m_ui.defaultUsernameLineEdit->setText(s.stringValue(MercurialSettings::userNameKey));
+ m_ui.defaultEmailLineEdit->setText(s.stringValue(MercurialSettings::userEmailKey));
+ m_ui.logEntriesCount->setValue(s.intValue(MercurialSettings::logCountKey));
+ m_ui.timeout->setValue(s.intValue(MercurialSettings::timeoutKey));
+ m_ui.promptOnSubmitCheckBox->setChecked(s.boolValue(MercurialSettings::promptOnSubmitKey));
}
QString OptionsPageWidget::searchKeywords() const
#include "vcsbaseclientsettings.h"
#include "vcsbaseeditorparameterwidget.h"
-#include <QtDebug>
-
#include <coreplugin/icore.h>
#include <coreplugin/editormanager/editormanager.h>
#include <coreplugin/vcsmanager.h>
void annotateRevision(QString source, QString change, int lineNumber);
void saveSettings();
+ void updateJobRunnerSettings();
+
VCSJobRunner *m_jobManager;
Core::ICore *m_core;
VCSBaseClientSettings *m_clientSettings;
m_clientSettings->writeSettings(m_core->settings());
}
+void VCSBaseClientPrivate::updateJobRunnerSettings()
+{
+ if (m_jobManager && m_clientSettings) {
+ m_jobManager->setBinary(m_clientSettings->stringValue(VCSBaseClientSettings::binaryPathKey));
+ m_jobManager->setTimeoutMs(m_clientSettings->intValue(VCSBaseClientSettings::timeoutKey) * 1000);
+ }
+}
+
VCSBaseClient::StatusItem::StatusItem()
{
}
vcsProcess.setWorkingDirectory(workingDir);
VCSJobRunner::setProcessEnvironment(&vcsProcess);
- const QString binary = settings()->binary();
- const QStringList arguments = settings()->standardArguments() + args;
+ const QString binary = settings()->stringValue(VCSBaseClientSettings::binaryPathKey);
VCSBase::VCSBaseOutputWindow *outputWindow = VCSBase::VCSBaseOutputWindow::instance();
outputWindow->appendCommand(workingDir, binary, args);
- vcsProcess.start(binary, arguments);
+ vcsProcess.start(binary, args);
if (!vcsProcess.waitForStarted()) {
outputWindow->appendError(VCSJobRunner::msgStartFailed(binary, vcsProcess.errorString()));
vcsProcess.closeWriteChannel();
QByteArray stdErr;
- if (!Utils::SynchronousProcess::readDataFromProcess(vcsProcess, settings()->timeoutMilliSeconds(),
+ const int timeoutSec = settings()->intValue(VCSBaseClientSettings::timeoutKey);
+ if (!Utils::SynchronousProcess::readDataFromProcess(vcsProcess, timeoutSec * 1000,
output, &stdErr, true)) {
Utils::SynchronousProcess::stopProcess(vcsProcess);
- outputWindow->appendError(VCSJobRunner::msgTimeout(binary, settings()->timeoutSeconds()));
+ outputWindow->appendError(VCSJobRunner::msgTimeout(binary, timeoutSec));
return false;
}
if (!stdErr.isEmpty())
unsigned flags,
QTextCodec *outputCodec)
{
- const QString binary = settings()->binary();
- const QStringList arguments = settings()->standardArguments() + args;
- return VCSBase::VCSBasePlugin::runVCS(workingDirectory, binary, arguments,
- settings()->timeoutMilliSeconds(),
- flags, outputCodec);
+ const QString binary = settings()->stringValue(VCSBaseClientSettings::binaryPathKey);
+ const int timeoutSec = settings()->intValue(VCSBaseClientSettings::timeoutKey);
+ return VCSBase::VCSBasePlugin::runVCS(workingDirectory, binary, args,
+ timeoutSec * 1000, flags, outputCodec);
}
void VCSBaseClient::annotate(const QString &workingDir, const QString &file,
void VCSBaseClient::handleSettingsChanged()
{
if (d->m_jobManager) {
- d->m_jobManager->setSettings(settings()->binary(),
- settings()->standardArguments(),
- settings()->timeoutMilliSeconds());
+ d->updateJobRunnerSettings();
d->m_jobManager->restart();
}
}
QString VCSBaseClient::vcsEditorTitle(const QString &vcsCmd, const QString &sourceId) const
{
- return QFileInfo(settings()->binary()).baseName() +
+ const QString binary = settings()->stringValue(VCSBaseClientSettings::binaryPathKey);
+ return QFileInfo(binary).baseName() +
QLatin1Char(' ') + vcsCmd + QLatin1Char(' ') +
QFileInfo(sourceId).fileName();
}
{
if (!d->m_jobManager) {
d->m_jobManager = new VCSJobRunner();
- d->m_jobManager->setSettings(settings()->binary(),
- settings()->standardArguments(),
- settings()->timeoutMilliSeconds());
+ d->updateJobRunnerSettings();
d->m_jobManager->start();
}
d->m_jobManager->enqueueJob(job);
#include <QtCore/QSettings>
-using namespace VCSBase;
+namespace {
-enum { timeOutDefaultSeconds = 30 };
+class SettingValue
+{
+public:
+ union Composite
+ {
+ QString *strPtr; // Union can't store class objects ...
+ int intValue;
+ bool boolValue;
+ };
+
+ SettingValue() :
+ m_type(QVariant::Invalid)
+ {
+ }
+
+ explicit SettingValue(const QVariant &v) :
+ m_type(v.type())
+ {
+ switch (v.type()) {
+ case QVariant::UInt:
+ m_type = QVariant::Int;
+ case QVariant::Int:
+ m_comp.intValue = v.toInt();
+ break;
+ case QVariant::Bool:
+ m_comp.boolValue = v.toBool();
+ break;
+ case QVariant::String:
+ m_comp.strPtr = new QString(v.toString());
+ break;
+ default:
+ m_type = QVariant::Invalid;
+ break;
+ }
+ }
+
+ SettingValue(const SettingValue &other) :
+ m_comp(other.m_comp),
+ m_type(other.type())
+ {
+ copyInternalString(other);
+ }
+
+ ~SettingValue()
+ {
+ deleteInternalString();
+ }
+
+ SettingValue &operator=(const SettingValue &other)
+ {
+ if (this != &other) {
+ deleteInternalString();
+ m_type = other.type();
+ m_comp = other.m_comp;
+ copyInternalString(other);
+ }
+ return *this;
+ }
+
+ QString stringValue(const QString &defaultString = QString()) const
+ {
+ if (type() == QVariant::String && m_comp.strPtr != 0)
+ return *(m_comp.strPtr);
+ return defaultString;
+ }
+
+ QVariant::Type type() const
+ {
+ return m_type;
+ }
+
+ static bool isUsableVariantType(QVariant::Type varType)
+ {
+ return varType == QVariant::UInt || varType == QVariant::Int ||
+ varType == QVariant::Bool || varType == QVariant::String;
+ }
+
+ Composite m_comp;
+
+private:
+ void deleteInternalString()
+ {
+ if (m_type == QVariant::String && m_comp.strPtr != 0) {
+ delete m_comp.strPtr;
+ m_comp.strPtr = 0;
+ }
+ }
+
+ void copyInternalString(const SettingValue &other)
+ {
+ if (type() == QVariant::String) {
+ const QString *otherString = other.m_comp.strPtr;
+ m_comp.strPtr = new QString(otherString != 0 ? *otherString : QString());
+ }
+ }
+
+ QVariant::Type m_type;
+};
+
+bool operator==(const SettingValue &lhs, const SettingValue &rhs)
+{
+ if (lhs.type() == rhs.type()) {
+ switch (lhs.type()) {
+ case QVariant::Int:
+ return lhs.m_comp.intValue == rhs.m_comp.intValue;
+ case QVariant::Bool:
+ return lhs.m_comp.boolValue == rhs.m_comp.boolValue;
+ case QVariant::String:
+ return lhs.stringValue() == rhs.stringValue();
+ default:
+ return false;
+ }
+ }
+ return false;
+}
+
+} // Anonymous namespace
+
+namespace VCSBase {
+
+class VCSBaseClientSettingsPrivate : public QSharedData
+{
+public:
+ VCSBaseClientSettingsPrivate()
+ {
+ }
+
+ VCSBaseClientSettingsPrivate(const VCSBaseClientSettingsPrivate &other) :
+ QSharedData(other),
+ m_valueHash(other.m_valueHash),
+ m_defaultValueHash(other.m_defaultValueHash),
+ m_settingsGroup(other.m_settingsGroup)
+ {
+ }
+
+ QHash<QString, SettingValue> m_valueHash;
+ QVariantHash m_defaultValueHash;
+ QString m_settingsGroup;
+};
/*!
\class VCSBase::VCSBaseClientSettings
\sa VCSBase::VCSBaseClient
*/
+const QLatin1String VCSBaseClientSettings::binaryPathKey("BinaryPath");
+const QLatin1String VCSBaseClientSettings::userNameKey("Username");
+const QLatin1String VCSBaseClientSettings::userEmailKey("UserEmail");
+const QLatin1String VCSBaseClientSettings::logCountKey("LogCount");
+const QLatin1String VCSBaseClientSettings::promptOnSubmitKey("PromptOnSubmit");
+const QLatin1String VCSBaseClientSettings::timeoutKey("Timeout");
+
VCSBaseClientSettings::VCSBaseClientSettings() :
- m_logCount(0),
- m_prompt(true),
- m_timeoutSeconds(timeOutDefaultSeconds)
+ d(new VCSBaseClientSettingsPrivate)
{
+ declareKey(binaryPathKey, QLatin1String(""));
+ declareKey(userNameKey, QLatin1String(""));
+ declareKey(userEmailKey, QLatin1String(""));
+ declareKey(logCountKey, 100);
+ declareKey(promptOnSubmitKey, true);
+ declareKey(timeoutKey, 30);
}
-VCSBaseClientSettings::~VCSBaseClientSettings()
-{ }
-
-QString VCSBaseClientSettings::binary() const
+VCSBaseClientSettings::VCSBaseClientSettings(const VCSBaseClientSettings &other) :
+ d(other.d)
{
- if (m_binary.isEmpty())
- return defaultBinary(); // Fallback binary if not specified
- return m_binary;
}
-void VCSBaseClientSettings::setBinary(const QString &b)
+VCSBaseClientSettings &VCSBaseClientSettings::operator=(const VCSBaseClientSettings &other)
{
- m_binary = b;
+ if (this != &other)
+ d = other.d;
+ return *this;
}
-QStringList VCSBaseClientSettings::standardArguments() const
+VCSBaseClientSettings::~VCSBaseClientSettings()
{
- return m_standardArguments;
}
-QString VCSBaseClientSettings::userName() const
+void VCSBaseClientSettings::writeSettings(QSettings *settings) const
{
- return m_user;
+ settings->beginGroup(settingsGroup());
+ foreach (const QString &key, keys())
+ settings->setValue(key, value(key));
+ settings->endGroup();
}
-void VCSBaseClientSettings::setUserName(const QString &u)
+void VCSBaseClientSettings::readSettings(const QSettings *settings)
{
- m_user = u;
+ const QString keyRoot = settingsGroup() + QLatin1Char('/');
+ foreach (const QString &key, keys()) {
+ const QVariant value = settings->value(keyRoot + key, keyDefaultValue(key));
+ // For some reason QSettings always return QVariant(QString) when the
+ // key exists. The type is explicited to avoid wrong conversions
+ switch (valueType(key)) {
+ case QVariant::Int:
+ setValue(key, value.toInt());
+ break;
+ case QVariant::Bool:
+ setValue(key, value.toBool());
+ break;
+ case QVariant::String:
+ setValue(key, value.toString());
+ break;
+ default:
+ break;
+ }
+ }
}
-QString VCSBaseClientSettings::email() const
+bool VCSBaseClientSettings::equals(const VCSBaseClientSettings &rhs) const
{
- return m_mail;
+ if (this == &rhs)
+ return true;
+ return d->m_valueHash == rhs.d->m_valueHash;
}
-void VCSBaseClientSettings::setEmail(const QString &m)
+QStringList VCSBaseClientSettings::keys() const
{
- m_mail = m;
+ return d->m_valueHash.keys();
}
-int VCSBaseClientSettings::logCount() const
+bool VCSBaseClientSettings::hasKey(const QString &key) const
{
- return m_logCount;
+ return d->m_valueHash.contains(key);
}
-void VCSBaseClientSettings::setLogCount(int l)
+int *VCSBaseClientSettings::intPointer(const QString &key)
{
- m_logCount = l;
+ if (hasKey(key))
+ return &(d->m_valueHash[key].m_comp.intValue);
+ return 0;
}
-bool VCSBaseClientSettings::prompt() const
+bool *VCSBaseClientSettings::boolPointer(const QString &key)
{
- return m_prompt;
+ if (hasKey(key))
+ return &(d->m_valueHash[key].m_comp.boolValue);
+ return 0;
}
-void VCSBaseClientSettings::setPrompt(bool b)
+QString *VCSBaseClientSettings::stringPointer(const QString &key)
{
- m_prompt = b;
+ if (hasKey(key))
+ return d->m_valueHash[key].m_comp.strPtr;
+ return 0;
}
-int VCSBaseClientSettings::timeoutMilliSeconds() const
+int VCSBaseClientSettings::intValue(const QString &key, int defaultValue) const
{
- //return timeout is in Ms
- return m_timeoutSeconds * 1000;
+ if (hasKey(key))
+ return d->m_valueHash[key].m_comp.intValue;
+ return defaultValue;
}
-int VCSBaseClientSettings::timeoutSeconds() const
+bool VCSBaseClientSettings::boolValue(const QString &key, bool defaultValue) const
{
- //return timeout in seconds (as the user specifies on the options page
- return m_timeoutSeconds;
+ if (hasKey(key))
+ return d->m_valueHash[key].m_comp.boolValue;
+ return defaultValue;
}
-void VCSBaseClientSettings::setTimeoutSeconds(int s)
+QString VCSBaseClientSettings::stringValue(const QString &key, const QString &defaultValue) const
{
- m_timeoutSeconds = s;
+ if (hasKey(key))
+ return d->m_valueHash[key].stringValue(defaultValue);
+ return defaultValue;
}
-QString VCSBaseClientSettings::settingsGroup() const
+QVariant VCSBaseClientSettings::value(const QString &key) const
{
- return m_settingsGroup;
+ switch (valueType(key)) {
+ case QVariant::Int:
+ return intValue(key);
+ case QVariant::Bool:
+ return boolValue(key);
+ case QVariant::String:
+ return stringValue(key);
+ case QVariant::Invalid:
+ return QVariant();
+ default:
+ return QVariant();
+ }
}
-void VCSBaseClientSettings::setSettingsGroup(const QString &group)
+void VCSBaseClientSettings::setValue(const QString &key, const QVariant &v)
{
- m_settingsGroup = group;
+ if (SettingValue::isUsableVariantType(valueType(key)))
+ d->m_valueHash.insert(key, SettingValue(v));
}
-void VCSBaseClientSettings::writeSettings(QSettings *settings) const
+QVariant::Type VCSBaseClientSettings::valueType(const QString &key) const
{
- settings->beginGroup(settingsGroup());
- settings->setValue(QLatin1String("VCS_Path"), m_binary);
- settings->setValue(QLatin1String("VCS_Username"), m_user);
- settings->setValue(QLatin1String("VCS_Email"), m_mail);
- settings->setValue(QLatin1String("VCS_LogCount"), m_logCount);
- settings->setValue(QLatin1String("VCS_PromptOnSubmit"), m_prompt);
- settings->setValue(QLatin1String("VCS_Timeout"), m_timeoutSeconds);
- settings->endGroup();
+ if (hasKey(key))
+ return d->m_valueHash[key].type();
+ return QVariant::Invalid;
}
-void VCSBaseClientSettings::readSettings(const QSettings *settings)
+QString VCSBaseClientSettings::settingsGroup() const
{
- const QString keyRoot = settingsGroup() + QLatin1Char('/');
- m_binary = settings->value(keyRoot + QLatin1String("VCS_Path"), defaultBinary()).toString();
- m_user = settings->value(keyRoot + QLatin1String("VCS_Username"), QString()).toString();
- m_mail = settings->value(keyRoot + QLatin1String("VCS_Email"), QString()).toString();
- m_logCount = settings->value(keyRoot + QLatin1String("VCS_LogCount"), QString()).toInt();
- m_prompt = settings->value(keyRoot + QLatin1String("VCS_PromptOnSubmit"), QString()).toBool();
- m_timeoutSeconds = settings->value(keyRoot + QLatin1String("VCS_Timeout"), timeOutDefaultSeconds).toInt();
+ return d->m_settingsGroup;
}
-bool VCSBaseClientSettings::equals(const VCSBaseClientSettings &rhs) const
+void VCSBaseClientSettings::setSettingsGroup(const QString &group)
{
- return m_binary == rhs.m_binary && m_standardArguments == rhs.m_standardArguments
- && m_user == rhs.m_user && m_mail == rhs.m_mail
- && m_logCount == rhs.m_logCount && m_prompt == rhs.m_prompt
- && m_timeoutSeconds == rhs.m_timeoutSeconds;
+ d->m_settingsGroup = group;
}
-QString VCSBaseClientSettings::defaultBinary() const
+void VCSBaseClientSettings::declareKey(const QString &key, const QVariant &defaultValue)
{
- return m_defaultBinary;
+ if (SettingValue::isUsableVariantType(defaultValue.type())) {
+ d->m_valueHash.insert(key, SettingValue(defaultValue));
+ d->m_defaultValueHash.insert(key, defaultValue);
+ }
}
-void VCSBaseClientSettings::setDefaultBinary(const QString &bin)
+QVariant VCSBaseClientSettings::keyDefaultValue(const QString &key) const
{
- m_defaultBinary = bin;
+ if (d->m_defaultValueHash.contains(key))
+ return d->m_defaultValueHash.value(key);
+ return QVariant(valueType(key));
}
+
+} // namespace VCSBase
#include "vcsbase_global.h"
#include <QtCore/QString>
#include <QtCore/QStringList>
+#include <QtCore/QVariant>
+#include <QtCore/QSharedDataPointer>
QT_BEGIN_NAMESPACE
class QSettings;
namespace VCSBase {
+class VCSBaseClientSettingsPrivate;
+
class VCSBASE_EXPORT VCSBaseClientSettings
{
public:
+ static const QLatin1String binaryPathKey;
+ static const QLatin1String userNameKey;
+ static const QLatin1String userEmailKey;
+ static const QLatin1String logCountKey;
+ static const QLatin1String promptOnSubmitKey;
+ static const QLatin1String timeoutKey; // Seconds
+
VCSBaseClientSettings();
+ VCSBaseClientSettings(const VCSBaseClientSettings &other);
+ VCSBaseClientSettings &operator=(const VCSBaseClientSettings &other);
virtual ~VCSBaseClientSettings();
- QString binary() const;
- void setBinary(const QString &);
+ void writeSettings(QSettings *settings) const;
+ void readSettings(const QSettings *settings);
- // Calculated
- QStringList standardArguments() const;
+ bool equals(const VCSBaseClientSettings &rhs) const;
- QString userName() const;
- void setUserName(const QString &);
+ QStringList keys() const;
+ bool hasKey(const QString &key) const;
- QString email() const;
- void setEmail(const QString &);
+ int *intPointer(const QString &key);
+ int intValue(const QString &key, int defaultValue = 0) const;
- int logCount() const;
- void setLogCount(int l);
+ bool *boolPointer(const QString &key);
+ bool boolValue(const QString &key, bool defaultValue = false) const;
- bool prompt() const;
- void setPrompt(bool b);
+ QString *stringPointer(const QString &key);
+ QString stringValue(const QString &key, const QString &defaultValue = QString()) const;
- int timeoutMilliSeconds() const;
- int timeoutSeconds() const;
- void setTimeoutSeconds(int s);
+ QVariant value(const QString &key) const;
+ void setValue(const QString &key, const QVariant &v);
+ QVariant::Type valueType(const QString &key) const;
+protected:
QString settingsGroup() const;
void setSettingsGroup(const QString &group);
- virtual void writeSettings(QSettings *settings) const;
- virtual void readSettings(const QSettings *settings);
-
- virtual bool equals(const VCSBaseClientSettings &rhs) const;
-
-protected:
- QString defaultBinary() const;
- void setDefaultBinary(const QString &bin);
+ void declareKey(const QString &key, const QVariant &defaultValue);
+ QVariant keyDefaultValue(const QString &key) const;
private:
- QString m_binary;
- QString m_defaultBinary;
- QStringList m_standardArguments;
- QString m_user;
- QString m_mail;
- int m_logCount;
- bool m_prompt;
- int m_timeoutSeconds;
- QString m_settingsGroup;
+ friend bool equals(const VCSBaseClientSettings &rhs);
+ friend class VCSBaseClientSettingsPrivate;
+ QSharedDataPointer<VCSBaseClientSettingsPrivate> d;
};
inline bool operator==(const VCSBaseClientSettings &s1, const VCSBaseClientSettings &s2)
QWaitCondition m_waiter;
bool m_keepRunning;
QString m_binary;
- QStringList m_standardArguments;
- int m_timeoutMS;
+ int m_timeoutMs;
};
VCSJobRunnerPrivate::VCSJobRunnerPrivate() :
- m_keepRunning(true), m_timeoutMS(30000)
+ m_keepRunning(true), m_timeoutMs(30000)
{
}
p->setProcessEnvironment(env);
}
-void VCSJobRunner::setSettings(const QString &bin,
- const QStringList &stdArgs,
- int timeoutMsec)
+const QString &VCSJobRunner::binary() const
+{
+ return d->m_binary;
+}
+
+void VCSJobRunner::setBinary(const QString &bin)
{
d->m_binary = bin;
- d->m_standardArguments = stdArgs;
- d->m_timeoutMS = timeoutMsec;
+}
+
+int VCSJobRunner::timeoutMs() const
+{
+ return d->m_timeoutMs;
+}
+
+void VCSJobRunner::setTimeoutMs(int msec)
+{
+ d->m_timeoutMs = msec;
}
void VCSJobRunner::task(const QSharedPointer<VCSJob> &job)
DisconnectSignalHelper autoDisconnectOutputSig(this, SIGNAL(output(QByteArray)));
Q_UNUSED(autoDisconnectOutputSig);
- const QStringList args = d->m_standardArguments + taskData->arguments();
- emit commandStarted(VCSBase::VCSBaseOutputWindow::msgExecutionLogEntry(taskData->workingDirectory(), d->m_binary, args));
+ // Check that the binary path is not empty
+ if (binary().trimmed().isEmpty()) {
+ emit error(tr("Unable to start process, binary is empty"));
+ return;
+ }
+
+ const QStringList args = taskData->arguments();
+ emit commandStarted(VCSBase::VCSBaseOutputWindow::msgExecutionLogEntry(taskData->workingDirectory(), binary(), args));
//infom the user of what we are going to try and perform
if (Constants::Internal::debug)
vcsProcess->setWorkingDirectory(taskData->workingDirectory());
VCSJobRunner::setProcessEnvironment(vcsProcess.data());
- vcsProcess->start(d->m_binary, args);
+ vcsProcess->start(binary(), args);
if (!vcsProcess->waitForStarted()) {
- emit error(msgStartFailed(d->m_binary, vcsProcess->errorString()));
+ emit error(msgStartFailed(binary(), vcsProcess->errorString()));
return;
}
QByteArray stdOutput;
QByteArray stdErr;
- if (!Utils::SynchronousProcess::readDataFromProcess(*vcsProcess, d->m_timeoutMS, &stdOutput, &stdErr, false)) {
+ if (!Utils::SynchronousProcess::readDataFromProcess(*vcsProcess, timeoutMs(), &stdOutput, &stdErr, false)) {
Utils::SynchronousProcess::stopProcess(*vcsProcess);
- emit error(msgTimeout(d->m_binary, d->m_timeoutMS / 1000));
+ emit error(msgTimeout(binary(), timeoutMs() / 1000));
return;
}
// Set environment for a VCS process to run in locale "C"
static void setProcessEnvironment(QProcess *p);
- void setSettings(const QString &bin, const QStringList &stdArgs, int timeoutMsec);
+ const QString &binary() const;
+ void setBinary(const QString &bin);
+
+ int timeoutMs() const;
+ void setTimeoutMs(int msec);
protected:
void run();
OSDN Git Service
