diff --git a/src/plugins/mercurial/commiteditor.cpp b/src/plugins/mercurial/commiteditor.cpp
index c7667ff131b9c9a92130e3fee15ff1806a2aad4e..80e0511aa48bcd4aaaca7847ef1f15f44a921585 100644
--- a/src/plugins/mercurial/commiteditor.cpp
+++ b/src/plugins/mercurial/commiteditor.cpp
@@ -63,11 +63,11 @@ void CommitEditor::setFields(const QFileInfo &repositoryRoot, const QString &bra
     fileModel = new VCSBase::SubmitFileModel(this);
 
     //TODO Messy tidy this up
-    typedef QPair<QString, QString> PAIR;
+    typedef QPair<QString, QString> StringStringPair;
     QStringList shouldTrack;
 
-    foreach (PAIR status, repoStatus) {
-        if (status.first == "Untracked")
+    foreach (const StringStringPair &status, repoStatus) {
+        if (status.first == QLatin1String("Untracked"))
             shouldTrack.append(status.second);
         else
             fileModel->addFile(status.second, status.first, false);
@@ -76,8 +76,8 @@ void CommitEditor::setFields(const QFileInfo &repositoryRoot, const QString &bra
     VCSBase::VCSBaseSubmitEditor::filterUntrackedFilesOfProject(repositoryRoot.absoluteFilePath(),
                                                                 &shouldTrack);
 
-    foreach (QString track, shouldTrack) {
-        foreach (PAIR status, repoStatus) {
+    foreach (const QString &track, shouldTrack) {
+        foreach (const StringStringPair &status, repoStatus) {
             if (status.second == track)
                 fileModel->addFile(status.second, status.first, false);
         }
diff --git a/src/plugins/mercurial/constants.h b/src/plugins/mercurial/constants.h
index 476d1e9b05f861ba9df412e155fa49406aad178e..5e8c8879eb94eb18fa3c3a444b5e6bbbe4d898e5 100644
--- a/src/plugins/mercurial/constants.h
+++ b/src/plugins/mercurial/constants.h
@@ -74,14 +74,6 @@ const char * const DIFFEXT = "diff";
 const char * const COMMITKIND = "Mercurial Commit Log Editor";
 const char * const COMMITMIMETYPE = "application/vnd.nokia.text.scs_mercurial_commitlog";
 
-#ifndef Q_WS_MAC
-const char * const MODIFIER = "Alt+";
-const char * const MENUKEY = "Alt+H, ";
-#else
-const char * const MODIFIER = "Meta+";
-const char * const MENUKEY = "Meta+H, ";
-#endif
-
 //menu items
 //File menu actions
 const char * const ANNOTATE = "Mercurial.Annotate";
diff --git a/src/plugins/mercurial/mercurialclient.cpp b/src/plugins/mercurial/mercurialclient.cpp
index 121cd030bf97998865832f9c51ae41cc75759939..e344eb61f8db0a6d69506539bdba2fcebf57db10 100644
--- a/src/plugins/mercurial/mercurialclient.cpp
+++ b/src/plugins/mercurial/mercurialclient.cpp
@@ -78,7 +78,7 @@ bool MercurialClient::add(const QString &filename)
 {
     QFileInfo file(filename);
     QStringList args;
-    args << "add" << file.absoluteFilePath();
+    args << QLatin1String("add") << file.absoluteFilePath();
 
     return hgProcessSync(file, args);
 }
@@ -87,7 +87,7 @@ bool MercurialClient::remove(const QString &filename)
 {
     QFileInfo file(filename);
     QStringList args;
-    args << "remove" << file.absoluteFilePath();
+    args << QLatin1String("remove") << file.absoluteFilePath();
 
     return hgProcessSync(file, args);
 }
@@ -95,15 +95,15 @@ bool MercurialClient::remove(const QString &filename)
 bool MercurialClient::manifestSync(const QString &filename)
 {
     QFileInfo file(filename);
-    QStringList args("manifest");
+    QStringList args(QLatin1String("manifest"));
 
     QByteArray output;
     hgProcessSync(file, args, &output);
 
-    QStringList files = QString::fromLocal8Bit(output).split('\n');
+    const QStringList files = QString::fromLocal8Bit(output).split(QLatin1Char('\n'));
 
-    foreach (QString fileName, files) {
-        QFileInfo managedFile(filename);
+    foreach (const QString &fileName, files) {
+        const QFileInfo managedFile(fileName);
         if (file == managedFile)
             return true;
     }
@@ -145,18 +145,18 @@ bool MercurialClient::hgProcessSync(const QFileInfo &file, const QStringList &ar
 QString MercurialClient::branchQuerySync(const QFileInfo &repositoryRoot)
 {
     QByteArray output;
-    if (hgProcessSync(repositoryRoot, QStringList("branch"), &output))
+    if (hgProcessSync(repositoryRoot, QStringList(QLatin1String("branch")), &output))
         return QTextCodec::codecForLocale()->toUnicode(output).trimmed();
 
-    return QString("Unknown Branch");
+    return QLatin1String("Unknown Branch");
 }
 
 void MercurialClient::annotate(const QFileInfo &file)
 {
     QStringList args;
-    args << "annotate" << "-u" << "-c" << "-d" << file.absoluteFilePath();
+    args << QLatin1String("annotate") << QLatin1String("-u") << QLatin1String("-c") << QLatin1String("-d") << file.absoluteFilePath();
 
-    const QString kind = Constants::ANNOTATELOG;
+    const QString kind = QLatin1String(Constants::ANNOTATELOG);
     const QString title = tr("Hg Annotate %1").arg(file.fileName());
 
     VCSBase::VCSBaseEditor *editor = createVCSEditor(kind, title, file.absolutePath(), true,
@@ -172,7 +172,8 @@ void MercurialClient::diff(const QFileInfo &fileOrDir)
     QString id;
     QString workingPath;
 
-    args << "diff" << "-g" << "-p" << "-U 8";
+    args << QLatin1String("diff") << QLatin1String("-g") << QLatin1String("-p")
+         << QLatin1String("-U 8");
 
     if (!fileOrDir.isDir()) {
         args.append(fileOrDir.absoluteFilePath());
@@ -183,7 +184,7 @@ void MercurialClient::diff(const QFileInfo &fileOrDir)
         workingPath = fileOrDir.absoluteFilePath();
     }
 
-    const QString kind = Constants::DIFFLOG;
+    const QString kind = QLatin1String(Constants::DIFFLOG);
     const QString title = tr("Hg diff %1").arg(fileOrDir.isDir() ? id : fileOrDir.fileName());
 
     VCSBase::VCSBaseEditor *editor = createVCSEditor(kind, title, workingPath, true,
@@ -195,12 +196,10 @@ void MercurialClient::diff(const QFileInfo &fileOrDir)
 
 void MercurialClient::log(const QFileInfo &fileOrDir)
 {
-    QStringList args;
+    QStringList args(QLatin1String("log"));
     QString id;
     QString workingDir;
 
-    args << "log";
-
     if (!fileOrDir.isDir()) {
         args.append(fileOrDir.absoluteFilePath());
         id = fileOrDir.absoluteFilePath();
@@ -210,7 +209,7 @@ void MercurialClient::log(const QFileInfo &fileOrDir)
         workingDir = fileOrDir.absoluteFilePath();
     }
 
-    const QString kind = Constants::FILELOG;
+    const QString kind = QLatin1String(Constants::FILELOG);
     const QString title = tr("Hg log %1").arg(fileOrDir.isDir() ? id : fileOrDir.fileName());
 
     VCSBase::VCSBaseEditor *editor = createVCSEditor(kind, title, workingDir, true,
@@ -222,15 +221,14 @@ void MercurialClient::log(const QFileInfo &fileOrDir)
 
 void MercurialClient::revert(const QFileInfo &fileOrDir, const QString &revision)
 {
-    QStringList args;
-    args << "revert";
+    QStringList args(QLatin1String("revert"));
 
     if (!revision.isEmpty())
-        args << "-r" << revision;
+        args << QLatin1String("-r") << revision;
     if (!fileOrDir.isDir())
         args.append(fileOrDir.absoluteFilePath());
     else
-        args.append("--all");
+        args.append(QLatin1String("--all"));
 
     QSharedPointer<HgTask> job(new HgTask(fileOrDir.isDir() ? fileOrDir.absoluteFilePath() :
                                           fileOrDir.absolutePath(), args, false));
@@ -240,7 +238,7 @@ void MercurialClient::revert(const QFileInfo &fileOrDir, const QString &revision
 void MercurialClient::status(const QFileInfo &fileOrDir)
 {
     QStringList args;
-    args << "status";
+    args << QLatin1String("status");
     if (!fileOrDir.isDir())
         args.append(fileOrDir.absoluteFilePath());
 
@@ -266,19 +264,19 @@ void MercurialClient::statusParser(const QByteArray &data)
 
     QStringList rawStatusList = QTextCodec::codecForLocale()->toUnicode(data).split(QLatin1Char('\n'));
 
-    foreach (QString string, rawStatusList) {
+    foreach (const QString &string, rawStatusList) {
         QPair<QString, QString> status;
 
-        if (string.startsWith('M'))
-            status.first = "Modified";
-        else if (string.startsWith('A'))
-            status.first = "Added";
-        else if (string.startsWith('R'))
-            status.first = "Removed";
-        else if (string.startsWith('!'))
-            status.first = "Deleted";
-        else if (string.startsWith('?'))
-            status.first = "Untracked";
+        if (string.startsWith(QLatin1Char('M')))
+            status.first = QLatin1String("Modified");
+        else if (string.startsWith(QLatin1Char('A')))
+            status.first = QLatin1String("Added");
+        else if (string.startsWith(QLatin1Char('R')))
+            status.first = QLatin1String("Removed");
+        else if (string.startsWith(QLatin1Char('!')))
+            status.first = QLatin1String("Deleted");
+        else if (string.startsWith(QLatin1Char('?')))
+            status.first = QLatin1String("Untracked");
         else
             continue;
 
@@ -294,10 +292,8 @@ void MercurialClient::statusParser(const QByteArray &data)
 void MercurialClient::import(const QFileInfo &repositoryRoot, const QStringList &files)
 {
     QStringList args;
-    args << "import" << "--no-commit";
-
-    foreach (QString file, files)
-        args.append(file);
+    args << QLatin1String("import") << QLatin1String("--no-commit");
+    args += files;
 
     QSharedPointer<HgTask> job(new HgTask(repositoryRoot.absoluteFilePath(), args, false));
     jobManager->enqueueJob(job);
@@ -306,7 +302,7 @@ void MercurialClient::import(const QFileInfo &repositoryRoot, const QStringList
 void MercurialClient::pull(const QFileInfo &repositoryRoot, const QString &repository)
 {
     QStringList args;
-    args << "pull";
+    args << QLatin1String("pull");
     if (!repository.isEmpty())
         args.append(repository);
 
@@ -317,7 +313,7 @@ void MercurialClient::pull(const QFileInfo &repositoryRoot, const QString &repos
 void MercurialClient::push(const QFileInfo &repositoryRoot, const QString &repository)
 {
     QStringList args;
-    args << "push";
+    args << QLatin1String("push");
     if (!repository.isEmpty())
         args.append(repository);
 
@@ -328,13 +324,13 @@ void MercurialClient::push(const QFileInfo &repositoryRoot, const QString &repos
 void MercurialClient::incoming(const QFileInfo &repositoryRoot, const QString &repository)
 {
     QStringList args;
-    args << "incoming" << "-g" << "-p";
+    args << QLatin1String("incoming") << QLatin1String("-g") << QLatin1String("-p");
     if (!repository.isEmpty())
         args.append(repository);
 
     QString id = MercurialPlugin::instance()->currentProjectName();
 
-    const QString kind = Constants::DIFFLOG;
+    const QString kind = QLatin1String(Constants::DIFFLOG);
     const QString title = tr("Hg incoming %1").arg(id);
 
     VCSBase::VCSBaseEditor *editor = createVCSEditor(kind, title, repositoryRoot.absoluteFilePath(),
@@ -347,11 +343,11 @@ void MercurialClient::incoming(const QFileInfo &repositoryRoot, const QString &r
 void MercurialClient::outgoing(const QFileInfo &repositoryRoot)
 {
     QStringList args;
-    args << "outgoing" << "-g" << "-p";
+    args << QLatin1String("outgoing") << QLatin1String("-g") << QLatin1String("-p");
 
     QString id = MercurialPlugin::instance()->currentProjectName();
 
-    const QString kind = Constants::DIFFLOG;
+    const QString kind = QLatin1String(Constants::DIFFLOG);
     const QString title = tr("Hg outgoing %1").arg(id);
 
     VCSBase::VCSBaseEditor *editor = createVCSEditor(kind, title, repositoryRoot.absoluteFilePath(), true,
@@ -364,9 +360,10 @@ void MercurialClient::outgoing(const QFileInfo &repositoryRoot)
 void MercurialClient::view(const QString &source, const QString &id)
 {
     QStringList args;
-    args << "log" << "-p" << "-g" << "-r" << id;
+    args << QLatin1String("log") << QLatin1String("-p") << QLatin1String("-g")
+         << QLatin1String("-r") << id;
 
-    const QString kind = Constants::DIFFLOG;
+    const QString kind = QLatin1String(Constants::DIFFLOG);
     const QString title = tr("Hg log %1").arg(id);
 
     VCSBase::VCSBaseEditor *editor = createVCSEditor(kind, title, source,
@@ -378,9 +375,7 @@ void MercurialClient::view(const QString &source, const QString &id)
 
 void MercurialClient::update(const QFileInfo &repositoryRoot, const QString &revision)
 {
-    QStringList args;
-
-    args << "update";
+    QStringList args(QLatin1String("update"));
     if (!revision.isEmpty())
         args << revision;
 
@@ -393,7 +388,8 @@ void MercurialClient::commit(const QFileInfo &repositoryRoot, const QStringList
 {
     QStringList args;
 
-    args << "commit" << "-u" << commiterInfo << "-l" << commitMessageFile << files;
+    args << QLatin1String("commit") << QLatin1String("-u") << commiterInfo
+         << QLatin1String("-l") << commitMessageFile << files;
     QSharedPointer<HgTask> job(new HgTask(repositoryRoot.absoluteFilePath(), args, false));
     jobManager->enqueueJob(job);
 }
@@ -424,13 +420,14 @@ VCSBase::VCSBaseEditor *MercurialClient::createVCSEditor(const QString &kind, QS
 {
     VCSBase::VCSBaseEditor *baseEditor = 0;
     Core::IEditor* outputEditor = locateEditor(core, registerDynamicProperty, dynamicPropertyValue);
+    const QString progressMsg = tr("Working...");
     if (outputEditor) {
         // Exists already
-        outputEditor->createNew(tr("Working..."));
+        outputEditor->createNew(progressMsg);
         baseEditor = VCSBase::VCSBaseEditor::getVcsBaseEditor(outputEditor);
         QTC_ASSERT(baseEditor, return 0);
     } else {
-        outputEditor = core->editorManager()->openEditorWithContents(kind, &title, tr("Working..."));
+        outputEditor = core->editorManager()->openEditorWithContents(kind, &title, progressMsg);
         outputEditor->file()->setProperty(registerDynamicProperty, dynamicPropertyValue);
         baseEditor = VCSBase::VCSBaseEditor::getVcsBaseEditor(outputEditor);
         QTC_ASSERT(baseEditor, return 0);
diff --git a/src/plugins/mercurial/mercurialeditor.cpp b/src/plugins/mercurial/mercurialeditor.cpp
index 0431ef0af7d39cc4fbf30388c5318c8f5edfdc54..ba6989db5153a66a767f0cbeab661a57caa89801 100644
--- a/src/plugins/mercurial/mercurialeditor.cpp
+++ b/src/plugins/mercurial/mercurialeditor.cpp
@@ -47,11 +47,11 @@ using namespace Mercurial;
 
 MercurialEditor::MercurialEditor(const VCSBase::VCSBaseEditorParameters *type, QWidget *parent)
         : VCSBase::VCSBaseEditor(type, parent),
-        exactIdentifier12(Constants::CHANGEIDEXACT12),
-        exactIdentifier40(Constants::CHANGEIDEXACT40),
-        changesetIdentifier12(Constants::CHANGESETID12),
-        changesetIdentifier40(Constants::CHANGESETID40),
-        diffIdentifier(Constants::DIFFIDENTIFIER)
+        exactIdentifier12(QLatin1String(Constants::CHANGEIDEXACT12)),
+        exactIdentifier40(QLatin1String(Constants::CHANGEIDEXACT40)),
+        changesetIdentifier12(QLatin1String(Constants::CHANGESETID12)),
+        changesetIdentifier40(QLatin1String(Constants::CHANGESETID40)),
+        diffIdentifier(QLatin1String(Constants::DIFFIDENTIFIER))
 {
 }
 
diff --git a/src/plugins/mercurial/mercurialjobrunner.cpp b/src/plugins/mercurial/mercurialjobrunner.cpp
index 6f83f98882afdcaed9d75d759035ccbfb2867cf1..4b7611c8f1c1a7aee6922a62644198d888475922 100644
--- a/src/plugins/mercurial/mercurialjobrunner.cpp
+++ b/src/plugins/mercurial/mercurialjobrunner.cpp
@@ -36,9 +36,7 @@
 #include <vcsbase/vcsbaseeditor.h>
 
 #include <QtCore/QProcess>
-#include <QtCore/QTime>
 #include <QtCore/QString>
-#include <QtCore/QSettings>
 #include <QtCore/QDebug>
 
 using namespace Mercurial::Internal;
@@ -99,7 +97,7 @@ void MercurialJobRunner::restart()
 
 void MercurialJobRunner::getSettings()
 {
-    MercurialSettings *settings = MercurialPlugin::instance()->settings();
+    const MercurialSettings *settings = MercurialPlugin::instance()->settings();
     binary = settings->binary();
     timeout = settings->timeout();
     standardArguments = settings->standardArguments();
diff --git a/src/plugins/mercurial/mercurialplugin.cpp b/src/plugins/mercurial/mercurialplugin.cpp
index f2fb5692e1c78a45d3bde2f85769c85088b6e4fc..339a264380c208e9d91bbedd769d4c9071eda51a 100644
--- a/src/plugins/mercurial/mercurialplugin.cpp
+++ b/src/plugins/mercurial/mercurialplugin.cpp
@@ -201,10 +201,10 @@ MercurialSettings *MercurialPlugin::settings()
 
 void MercurialPlugin::createMenu()
 {
-    QList<int> context = QList<int>()<< core->uniqueIDManager()->uniqueIdentifier(Core::Constants::C_GLOBAL);
+    QList<int> context = QList<int>()<< core->uniqueIDManager()->uniqueIdentifier(QLatin1String(Core::Constants::C_GLOBAL));
 
     // Create menu item for Mercurial
-    mercurialContainer = actionManager->createMenu("Mercurial.MercurialMenu");
+    mercurialContainer = actionManager->createMenu(QLatin1String("Mercurial.MercurialMenu"));
     QMenu *menu = mercurialContainer->menu();
     menu->setTitle(tr("Mercurial"));
 
@@ -214,17 +214,17 @@ void MercurialPlugin::createMenu()
     }
 
     createFileActions(context);
-    createSeparator(context, "FileDirSeperator");
+    createSeparator(context, QLatin1String("FileDirSeperator"));
     createDirectoryActions(context);
-    createSeparator(context, "DirRepoSeperator");
+    createSeparator(context, QLatin1String("DirRepoSeperator"));
     createRepositoryActions(context);
-    createSeparator(context, "Repository Management");
+    createSeparator(context, QLatin1String("Repository Management"));
     createRepositoryManagementActions(context);
-    createSeparator(context, "LessUsedfunctionality");
+    createSeparator(context, QLatin1String("LessUsedfunctionality"));
     createLessUsedActions(context);
 
     // Request the Tools menu and add the Mercurial menu to it
-    Core::ActionContainer *toolsMenu = actionManager->actionContainer(Core::Constants::M_TOOLS);
+    Core::ActionContainer *toolsMenu = actionManager->actionContainer(QLatin1String(Core::Constants::M_TOOLS));
     toolsMenu->addMenu(mercurialContainer);
 
     connect(core, SIGNAL(contextChanged(Core::IContext *)), this, SLOT(updateActions()));
@@ -233,40 +233,40 @@ void MercurialPlugin::createMenu()
 
 }
 
-void MercurialPlugin::createFileActions(QList<int> &context)
+void MercurialPlugin::createFileActions(const QList<int> &context)
 {
     Core::Command *command;
 
     annotateFile = new Utils::ParameterAction(tr("Annotate Current File"), tr("Annotate \"%1\""), Utils::ParameterAction::AlwaysEnabled, this);
-    command = actionManager->registerAction(annotateFile, Constants::ANNOTATE, context);
+    command = actionManager->registerAction(annotateFile, QLatin1String(Constants::ANNOTATE), context);
     command->setAttribute(Core::Command::CA_UpdateText);
     connect(annotateFile, SIGNAL(triggered()), this, SLOT(annotateCurrentFile()));
     mercurialContainer->addAction(command);
 
     diffFile = new Utils::ParameterAction(tr("Diff Current File"), tr("Diff \"%1\""), Utils::ParameterAction::AlwaysEnabled, this);
-    command = actionManager->registerAction(diffFile, Constants::DIFF, context);
+    command = actionManager->registerAction(diffFile, QLatin1String(Constants::DIFF), context);
     command->setAttribute(Core::Command::CA_UpdateText);
-    command->setDefaultKeySequence(QKeySequence(tr(Constants::MENUKEY) + tr(Constants::MODIFIER) + "D"));
+    command->setDefaultKeySequence(QKeySequence(tr("Alt+H,Alt+D")));
     connect(diffFile, SIGNAL(triggered()), this, SLOT(diffCurrentFile()));
     mercurialContainer->addAction(command);
 
     logFile = new Utils::ParameterAction(tr("Log Current File"), tr("Log \"%1\""), Utils::ParameterAction::AlwaysEnabled, this);
-    command = actionManager->registerAction(logFile, Constants::LOG, context);
+    command = actionManager->registerAction(logFile, QLatin1String(Constants::LOG), context);
     command->setAttribute(Core::Command::CA_UpdateText);
-    command->setDefaultKeySequence(QKeySequence(tr(Constants::MENUKEY) + tr(Constants::MODIFIER) + "L"));
+    command->setDefaultKeySequence(QKeySequence(tr("Alt+H,Alt+L")));
     connect(logFile, SIGNAL(triggered()), this, SLOT(logCurrentFile()));
     mercurialContainer->addAction(command);
 
     revertFile = new Utils::ParameterAction(tr("Revert Current File"), tr("Revert \"%1\""), Utils::ParameterAction::AlwaysEnabled, this);
-    command = actionManager->registerAction(revertFile, Constants::REVERT, context);
+    command = actionManager->registerAction(revertFile, QLatin1String(Constants::REVERT), context);
     command->setAttribute(Core::Command::CA_UpdateText);
     connect(revertFile, SIGNAL(triggered()), this, SLOT(revertCurrentFile()));
     mercurialContainer->addAction(command);
 
     statusFile = new Utils::ParameterAction(tr("Status Current File"), tr("Status \"%1\""), Utils::ParameterAction::AlwaysEnabled, this);
-    command = actionManager->registerAction(statusFile, Constants::STATUS, context);
+    command = actionManager->registerAction(statusFile, QLatin1String(Constants::STATUS), context);
     command->setAttribute(Core::Command::CA_UpdateText);
-    command->setDefaultKeySequence(QKeySequence(tr(Constants::MENUKEY) + tr(Constants::MODIFIER) + "S"));
+    command->setDefaultKeySequence(QKeySequence(tr("Alt+H,Alt+S")));
     connect(statusFile, SIGNAL(triggered()), this, SLOT(statusCurrentFile()));
     mercurialContainer->addAction(command);
 }
@@ -299,32 +299,32 @@ void MercurialPlugin::statusCurrentFile()
     client->status(currentFile());
 }
 
-void MercurialPlugin::createDirectoryActions(QList<int> &context)
+void MercurialPlugin::createDirectoryActions(const QList<int> &context)
 {
     QAction *action;
     Core::Command *command;
 
     action = new QAction(tr("Diff"), this);
     actionList.append(action);
-    command = actionManager->registerAction(action, Constants::DIFFMULTI, context);
+    command = actionManager->registerAction(action, QLatin1String(Constants::DIFFMULTI), context);
     connect(action, SIGNAL(triggered()), this, SLOT(diffRepository()));
     mercurialContainer->addAction(command);
 
     action = new QAction(tr("Log"), this);
     actionList.append(action);
-    command = actionManager->registerAction(action, Constants::LOGMULTI, context);
+    command = actionManager->registerAction(action, QLatin1String(Constants::LOGMULTI), context);
     connect(action, SIGNAL(triggered()), this, SLOT(logRepository()));
     mercurialContainer->addAction(command);
 
     action = new QAction(tr("Revert"), this);
     actionList.append(action);
-    command = actionManager->registerAction(action, Constants::REVERTMULTI, context);
+    command = actionManager->registerAction(action, QLatin1String(Constants::REVERTMULTI), context);
     connect(action, SIGNAL(triggered()), this, SLOT(revertMulti()));
     mercurialContainer->addAction(command);
 
     action = new QAction(tr("Status"), this);
     actionList.append(action);
-    command = actionManager->registerAction(action, Constants::STATUSMULTI, context);
+    command = actionManager->registerAction(action, QLatin1String(Constants::STATUSMULTI), context);
     connect(action, SIGNAL(triggered()), this, SLOT(statusMulti()));
     mercurialContainer->addAction(command);
 }
@@ -352,48 +352,48 @@ void MercurialPlugin::statusMulti()
     client->status(currentProjectRoot());
 }
 
-void MercurialPlugin::createRepositoryActions(QList<int> &context)
+void MercurialPlugin::createRepositoryActions(const QList<int> &context)
 {
     QAction *action = new QAction(tr("Pull"), this);
     actionList.append(action);
-    Core::Command *command = actionManager->registerAction(action, Constants::PULL, context);
+    Core::Command *command = actionManager->registerAction(action, QLatin1String(Constants::PULL), context);
     connect(action, SIGNAL(triggered()), this, SLOT(pull()));
     mercurialContainer->addAction(command);
 
     action = new QAction(tr("Push"), this);
     actionList.append(action);
-    command = actionManager->registerAction(action, Constants::PUSH, context);
+    command = actionManager->registerAction(action, QLatin1String(Constants::PUSH), context);
     connect(action, SIGNAL(triggered()), this, SLOT(push()));
     mercurialContainer->addAction(command);
 
     action = new QAction(tr("Update"), this);
     actionList.append(action);
-    command = actionManager->registerAction(action, Constants::UPDATE, context);
+    command = actionManager->registerAction(action, QLatin1String(Constants::UPDATE), context);
     connect(action, SIGNAL(triggered()), this, SLOT(update()));
     mercurialContainer->addAction(command);
 
     action = new QAction(tr("Import"), this);
     actionList.append(action);
-    command = actionManager->registerAction(action, Constants::IMPORT, context);
+    command = actionManager->registerAction(action, QLatin1String(Constants::IMPORT), context);
     connect(action, SIGNAL(triggered()), this, SLOT(import()));
     mercurialContainer->addAction(command);
 
     action = new QAction(tr("Incoming"), this);
     actionList.append(action);
-    command = actionManager->registerAction(action, Constants::INCOMING, context);
+    command = actionManager->registerAction(action, QLatin1String(Constants::INCOMING), context);
     connect(action, SIGNAL(triggered()), this, SLOT(incoming()));
     mercurialContainer->addAction(command);
 
     action = new QAction(tr("Outgoing"), this);
     actionList.append(action);
-    command = actionManager->registerAction(action, Constants::OUTGOING, context);
+    command = actionManager->registerAction(action, QLatin1String(Constants::OUTGOING), context);
     connect(action, SIGNAL(triggered()), this, SLOT(outgoing()));
     mercurialContainer->addAction(command);
 
     action = new QAction(tr("Commit"), this);
     actionList.append(action);
-    command = actionManager->registerAction(action, Constants::COMMIT, context);
-    command->setDefaultKeySequence(QKeySequence(tr(Constants::MENUKEY) + tr(Constants::MODIFIER) + "C"));
+    command = actionManager->registerAction(action, QLatin1String(Constants::COMMIT), context);
+    command->setDefaultKeySequence(QKeySequence(tr("Alt+H,Alt+C")));
     connect(action, SIGNAL(triggered()), this, SLOT(commit()));
     mercurialContainer->addAction(command);
 }
@@ -401,7 +401,7 @@ void MercurialPlugin::createRepositoryActions(QList<int> &context)
 void MercurialPlugin::pull()
 {
     SrcDestDialog dialog;
-    dialog.setWindowTitle("Pull Source");
+    dialog.setWindowTitle(tr("Pull Source"));
     if (dialog.exec() != QDialog::Accepted)
         return;
     QString repository = dialog.getRepositoryString();
@@ -411,7 +411,7 @@ void MercurialPlugin::pull()
 void MercurialPlugin::push()
 {
     SrcDestDialog dialog;
-    dialog.setWindowTitle("Push Destination");
+    dialog.setWindowTitle(tr("Push Destination"));
     if (dialog.exec() != QDialog::Accepted)
         return;
     QString repository = dialog.getRepositoryString();
@@ -421,7 +421,7 @@ void MercurialPlugin::push()
 void MercurialPlugin::update()
 {
     RevertDialog updateDialog;
-    updateDialog.setWindowTitle("Update");
+    updateDialog.setWindowTitle(tr("Update"));
     if (updateDialog.exec() != QDialog::Accepted)
         return;
     client->update(currentProjectRoot(), updateDialog.revision());
@@ -443,7 +443,7 @@ void MercurialPlugin::import()
 void MercurialPlugin::incoming()
 {
     SrcDestDialog dialog;
-    dialog.setWindowTitle("Incoming Source");
+    dialog.setWindowTitle(tr("Incoming Source"));
     if (dialog.exec() != QDialog::Accepted)
         return;
     QString repository = dialog.getRepositoryString();
@@ -457,21 +457,21 @@ void MercurialPlugin::outgoing()
 
 void MercurialPlugin::createSubmitEditorActions()
 {
-    QList<int> context = QList<int>()<< core->uniqueIDManager()->uniqueIdentifier(Constants::COMMITKIND);
+    QList<int> context = QList<int>()<< core->uniqueIDManager()->uniqueIdentifier(QLatin1String(Constants::COMMITKIND));
     Core::Command *command;
 
     editorCommit = new QAction(VCSBase::VCSBaseSubmitEditor::submitIcon(), tr("Commit"), this);
-    command = actionManager->registerAction(editorCommit, Constants::COMMIT, context);
+    command = actionManager->registerAction(editorCommit, QLatin1String(Constants::COMMIT), context);
     connect(editorCommit, SIGNAL(triggered()), this, SLOT(commitFromEditor()));
 
     editorDiff = new QAction(VCSBase::VCSBaseSubmitEditor::diffIcon(), tr("Diff Selected Files"), this);
-    command = actionManager->registerAction(editorDiff, Constants::DIFFEDITOR, context);
+    command = actionManager->registerAction(editorDiff, QLatin1String(Constants::DIFFEDITOR), context);
 
     editorUndo = new QAction(tr("&Undo"), this);
-    command = actionManager->registerAction(editorUndo, Core::Constants::UNDO, context);
+    command = actionManager->registerAction(editorUndo, QLatin1String(Core::Constants::UNDO), context);
 
     editorRedo = new QAction(tr("&Redo"), this);
-    command = actionManager->registerAction(editorRedo, Core::Constants::REDO, context);
+    command = actionManager->registerAction(editorRedo, QLatin1String(Core::Constants::REDO), context);
 }
 
 void MercurialPlugin::commit()
@@ -506,7 +506,7 @@ void MercurialPlugin::showCommitWidget(const QList<QPair<QString, QString> > &st
     }
 
     Core::IEditor *editor = core->editorManager()->openEditor(changeLog->fileName(),
-                                                              Constants::COMMITKIND);
+                                                              QLatin1String(Constants::COMMITKIND));
     if (!editor) {
         outputWindow->appendError(tr("Unable to create an editor for the commit."));
         return;
@@ -535,8 +535,8 @@ void MercurialPlugin::showCommitWidget(const QList<QPair<QString, QString> > &st
 
 void MercurialPlugin::diffFromEditorSelected(const QStringList &files)
 {
-    foreach (QString file, files) {
-        QFileInfo toDiff(QDir(currentProjectRoot().absoluteFilePath()).absoluteFilePath(file));
+    foreach (const QString &file, files) {
+        const QFileInfo toDiff(QDir(currentProjectRoot().absoluteFilePath()).absoluteFilePath(file));
         client->diff(toDiff);
     }
 }
@@ -596,7 +596,7 @@ void MercurialPlugin::deleteCommitLog()
     }
 }
 
-void MercurialPlugin::createRepositoryManagementActions(QList<int> &context)
+void MercurialPlugin::createRepositoryManagementActions(const QList<int> &context)
 {
     //TODO create menu for these options
     Q_UNUSED(context);
@@ -608,7 +608,7 @@ void MercurialPlugin::createRepositoryManagementActions(QList<int> &context)
     //    mercurialContainer->addAction(command);
 }
 
-void MercurialPlugin::createLessUsedActions(QList<int> &context)
+void MercurialPlugin::createLessUsedActions(const QList<int> &context)
 {
     //TODO create menue for these options
     Q_UNUSED(context);
diff --git a/src/plugins/mercurial/mercurialplugin.h b/src/plugins/mercurial/mercurialplugin.h
index b061d15293bb5f7a80da27995ca3c3bd994abd70..331ef3142db966c599a4016b33428392f43f7da6 100644
--- a/src/plugins/mercurial/mercurialplugin.h
+++ b/src/plugins/mercurial/mercurialplugin.h
@@ -136,13 +136,12 @@ private:
     void createMenu();
     void createSubmitEditorActions();
     void createSeparator(const QList<int> &context, const QString &id);
-    void createFileActions(QList<int> &context);
-    void createDirectoryActions(QList<int> &context);
-    void createRepositoryActions(QList<int> &context);
-    void createRepositoryManagementActions(QList<int> &context);
-    void createLessUsedActions(QList<int> &context);
+    void createFileActions(const QList<int> &context);
+    void createDirectoryActions(const QList<int> &context);
+    void createRepositoryActions(const QList<int> &context);
+    void createRepositoryManagementActions(const QList<int> &context);
+    void createLessUsedActions(const QList<int> &context);
     void deleteCommitLog();
-    //QString getSettingsByKey(const char * const key);
 
     //Variables
     static MercurialPlugin *m_instance;
diff --git a/src/plugins/mercurial/mercurialsettings.cpp b/src/plugins/mercurial/mercurialsettings.cpp
index bf902d2b41316f696cded297ac33c84a637bb4ca..790da7777d1a634c0a91fa9864eaa1afe9e13a2e 100644
--- a/src/plugins/mercurial/mercurialsettings.cpp
+++ b/src/plugins/mercurial/mercurialsettings.cpp
@@ -42,49 +42,49 @@ MercurialSettings::MercurialSettings()
     readSettings();
 }
 
-QString MercurialSettings::binary()
+QString MercurialSettings::binary() const
 {
     return bin;
 }
 
-QString MercurialSettings::application()
+QString MercurialSettings::application() const
 {
     return app;
 }
 
-QStringList MercurialSettings::standardArguments()
+QStringList MercurialSettings::standardArguments() const
 {
     return standardArgs;
 }
 
-QString MercurialSettings::userName()
+QString MercurialSettings::userName() const
 {
     return user;
 }
 
-QString MercurialSettings::email()
+QString MercurialSettings::email() const
 {
     return mail;
 }
 
-int MercurialSettings::logCount()
+int MercurialSettings::logCount() const
 {
     return m_logCount;
 }
 
-int MercurialSettings::timeout()
+int MercurialSettings::timeout() const
 {
     //return timeout is in Ms
     return m_timeout * 1000;
 }
 
-int MercurialSettings::timeoutSeconds()
+int MercurialSettings::timeoutSeconds() const
 {
     //return timeout in seconds (as the user specifies on the options page
     return m_timeout;
 }
 
-bool MercurialSettings::prompt()
+bool MercurialSettings::prompt() const
 {
     return m_prompt;
 }
@@ -94,13 +94,13 @@ void MercurialSettings::writeSettings(const QString &application, const QString
 {
     QSettings *settings = Core::ICore::instance()->settings();
     if (settings) {
-        settings->beginGroup("Mercurial");
-        settings->setValue(Constants::MERCURIALPATH, application);
-        settings->setValue(Constants::MERCURIALUSERNAME, userName);
-        settings->setValue(Constants::MERCURIALEMAIL, email);
-        settings->setValue(Constants::MERCURIALLOGCOUNT, logCount);
-        settings->setValue(Constants::MERCURIALTIMEOUT, timeout);
-        settings->setValue(Constants::MERCURIALPROMPTSUBMIT, prompt);
+        settings->beginGroup(QLatin1String("Mercurial"));
+        settings->setValue(QLatin1String(Constants::MERCURIALPATH), application);
+        settings->setValue(QLatin1String(Constants::MERCURIALUSERNAME), userName);
+        settings->setValue(QLatin1String(Constants::MERCURIALEMAIL), email);
+        settings->setValue(QLatin1String(Constants::MERCURIALLOGCOUNT), logCount);
+        settings->setValue(QLatin1String(Constants::MERCURIALTIMEOUT), timeout);
+        settings->setValue(QLatin1String(Constants::MERCURIALPROMPTSUBMIT), prompt);
         settings->endGroup();
     }
 
@@ -117,13 +117,14 @@ void MercurialSettings::readSettings()
 {
     QSettings *settings = Core::ICore::instance()->settings();
     if (settings) {
-        settings->beginGroup("Mercurial");
-        app = settings->value(Constants::MERCURIALPATH, Constants::MERCURIALDEFAULT).toString();
-        user = settings->value(Constants::MERCURIALUSERNAME, QString()).toString();
-        mail = settings->value(Constants::MERCURIALEMAIL, QString()).toString();
-        m_logCount = settings->value(Constants::MERCURIALLOGCOUNT, 0).toInt();
-        m_timeout = settings->value(Constants::MERCURIALTIMEOUT, 30).toInt();
-        m_prompt = settings->value(Constants::MERCURIALPROMPTSUBMIT, true).toBool();
+        settings->beginGroup(QLatin1String("Mercurial"));
+        app = settings->value(QLatin1String(Constants::MERCURIALPATH),
+                              QLatin1String(Constants::MERCURIALDEFAULT)).toString();
+        user = settings->value(QLatin1String(Constants::MERCURIALUSERNAME), QString()).toString();
+        mail = settings->value(QLatin1String(Constants::MERCURIALEMAIL), QString()).toString();
+        m_logCount = settings->value(QLatin1String(Constants::MERCURIALLOGCOUNT), 0).toInt();
+        m_timeout = settings->value(QLatin1String(Constants::MERCURIALTIMEOUT), 30).toInt();
+        m_prompt = settings->value(QLatin1String(Constants::MERCURIALPROMPTSUBMIT), true).toBool();
         settings->endGroup();
     }
 
diff --git a/src/plugins/mercurial/mercurialsettings.h b/src/plugins/mercurial/mercurialsettings.h
index df1155afff511285c1306598173508245b6a9da1..e4a91628a190a0582b0b712848cc27e4e36b02d8 100644
--- a/src/plugins/mercurial/mercurialsettings.h
+++ b/src/plugins/mercurial/mercurialsettings.h
@@ -41,15 +41,15 @@ class MercurialSettings
 public:
     MercurialSettings();
 
-    QString binary();
-    QString application();
-    QStringList standardArguments();
-    QString userName();
-    QString email();
-    int logCount();
-    int timeout();
-    int timeoutSeconds();
-    bool prompt();
+    QString binary() const;
+    QString application() const;
+    QStringList standardArguments() const;
+    QString userName() const;
+    QString email() const;
+    int logCount() const;
+    int timeout() const;
+    int timeoutSeconds() const;
+    bool prompt() const;
     void writeSettings(const QString &application, const QString &userName,
                        const QString &email, int logCount, int timeout, bool prompt);
 private: