/**************************************************************************** ** ** Copyright (C) 2013 Digia Plc and/or its subsidiary(-ies). ** Contact: http://www.qt-project.org/legal ** ** This file is part of Qt Creator. ** ** Commercial License Usage ** Licensees holding valid commercial Qt licenses may use this file in ** accordance with the commercial license agreement provided with the ** Software or, alternatively, in accordance with the terms contained in ** a written agreement between you and Digia. For licensing terms and ** conditions see http://qt.digia.com/licensing. For further information ** use the contact form at http://qt.digia.com/contact-us. ** ** GNU Lesser General Public License Usage ** Alternatively, this file may be used under the terms of the GNU Lesser ** General Public License version 2.1 as published by the Free Software ** Foundation and appearing in the file LICENSE.LGPL included in the ** packaging of this file. Please review the following information to ** ensure the GNU Lesser General Public License version 2.1 requirements ** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html. ** ** In addition, as a special exception, Digia gives you certain additional ** rights. These rights are described in the Digia Qt LGPL Exception ** version 1.1, included in the file LGPL_EXCEPTION.txt in this package. ** ****************************************************************************/ #include "gitplugin.h" #include "changeselectiondialog.h" #include "commitdata.h" #include "gitclient.h" #include "gitconstants.h" #include "giteditor.h" #include "gitsubmiteditor.h" #include "gitversioncontrol.h" #include "branchdialog.h" #include "remotedialog.h" #include "clonewizard.h" #include "gitoriousclonewizard.h" #include "stashdialog.h" #include "settingspage.h" #include "resetdialog.h" #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include static const VcsBase::VcsBaseEditorParameters editorParameters[] = { { VcsBase::RegularCommandOutput, Git::Constants::GIT_COMMAND_LOG_EDITOR_ID, Git::Constants::GIT_COMMAND_LOG_EDITOR_DISPLAY_NAME, Git::Constants::C_GIT_COMMAND_LOG_EDITOR, "application/vnd.nokia.text.scs_git_commandlog", "gitlog"}, { VcsBase::LogOutput, Git::Constants::GIT_LOG_EDITOR_ID, Git::Constants::GIT_LOG_EDITOR_DISPLAY_NAME, Git::Constants::C_GIT_LOG_EDITOR, "application/vnd.nokia.text.scs_git_filelog", "gitfilelog"}, { VcsBase::AnnotateOutput, Git::Constants::GIT_BLAME_EDITOR_ID, Git::Constants::GIT_BLAME_EDITOR_DISPLAY_NAME, Git::Constants::C_GIT_BLAME_EDITOR, "application/vnd.nokia.text.scs_git_annotation", "gitsannotate"}, { VcsBase::DiffOutput, Git::Constants::GIT_DIFF_EDITOR_ID, Git::Constants::GIT_DIFF_EDITOR_DISPLAY_NAME, Git::Constants::C_GIT_DIFF_EDITOR, "text/x-patch","diff"} }; // Utility to find a parameter set by type static inline const VcsBase::VcsBaseEditorParameters *findType(int ie) { const VcsBase::EditorContentType et = static_cast(ie); return VcsBase::VcsBaseEditorWidget::findType(editorParameters, sizeof(editorParameters)/sizeof(VcsBase::VcsBaseEditorParameters), et); } Q_DECLARE_METATYPE(Git::Internal::GitClientMemberFunc) using namespace Git; using namespace Git::Internal; // GitPlugin GitPlugin *GitPlugin::m_instance = 0; GitPlugin::GitPlugin() : VcsBase::VcsBasePlugin(QLatin1String(Git::Constants::GITSUBMITEDITOR_ID)), m_commandLocator(0), m_showAction(0), m_submitCurrentAction(0), m_diffSelectedFilesAction(0), m_undoAction(0), m_redoAction(0), m_menuAction(0), m_applyCurrentFilePatchAction(0), m_gitClient(0), m_changeSelectionDialog(0), m_submitActionTriggered(false) { m_instance = this; const int mid = qRegisterMetaType(); Q_UNUSED(mid) m_fileActions.reserve(10); m_projectActions.reserve(10); m_repositoryActions.reserve(15); } GitPlugin::~GitPlugin() { cleanCommitMessageFile(); delete m_gitClient; m_instance = 0; } void GitPlugin::cleanCommitMessageFile() { if (!m_commitMessageFileName.isEmpty()) { QFile::remove(m_commitMessageFileName); m_commitMessageFileName.clear(); } } bool GitPlugin::isCommitEditorOpen() const { return !m_commitMessageFileName.isEmpty(); } GitPlugin *GitPlugin::instance() { return m_instance; } static const VcsBase::VcsBaseSubmitEditorParameters submitParameters = { Git::Constants::SUBMIT_MIMETYPE, Git::Constants::GITSUBMITEDITOR_ID, Git::Constants::GITSUBMITEDITOR_DISPLAY_NAME, Git::Constants::C_GITSUBMITEDITOR }; // Create a parameter action ParameterActionCommandPair GitPlugin::createParameterAction(Core::ActionContainer *ac, const QString &defaultText, const QString ¶meterText, const Core::Id &id, const Core::Context &context, bool addToLocator) { Utils::ParameterAction *action = new Utils::ParameterAction(defaultText, parameterText, Utils::ParameterAction::EnabledWithParameter, this); Core::Command *command = Core::ActionManager::registerAction(action, id, context); command->setAttribute(Core::Command::CA_UpdateText); ac->addAction(command); if (addToLocator) m_commandLocator->appendCommand(command); return ParameterActionCommandPair(action, command); } // Create an action to act on a file with a slot. ParameterActionCommandPair GitPlugin::createFileAction(Core::ActionContainer *ac, const QString &defaultText, const QString ¶meterText, const Core::Id &id, const Core::Context &context, bool addToLocator, const char *pluginSlot) { const ParameterActionCommandPair rc = createParameterAction(ac, defaultText, parameterText, id, context, addToLocator); m_fileActions.push_back(rc.first); connect(rc.first, SIGNAL(triggered()), this, pluginSlot); return rc; } // Create an action to act on a project with slot. ParameterActionCommandPair GitPlugin::createProjectAction(Core::ActionContainer *ac, const QString &defaultText, const QString ¶meterText, const Core::Id &id, const Core::Context &context, bool addToLocator, const char *pluginSlot) { const ParameterActionCommandPair rc = createParameterAction(ac, defaultText, parameterText, id, context, addToLocator); m_projectActions.push_back(rc.first); connect(rc.first, SIGNAL(triggered()), this, pluginSlot); return rc; } // Create an action to act on the repository ActionCommandPair GitPlugin::createRepositoryAction(Core::ActionContainer *ac, const QString &text, const Core::Id &id, const Core::Context &context, bool addToLocator) { QAction *action = new QAction(text, this); Core::Command *command = Core::ActionManager::registerAction(action, id, context); ac->addAction(command); m_repositoryActions.push_back(action); if (addToLocator) m_commandLocator->appendCommand(command); return ActionCommandPair(action, command); } // Create an action to act on the repository with slot ActionCommandPair GitPlugin::createRepositoryAction(Core::ActionContainer *ac, const QString &text, const Core::Id &id, const Core::Context &context, bool addToLocator, const char *pluginSlot) { const ActionCommandPair rc = createRepositoryAction(ac, text, id, context, addToLocator); connect(rc.first, SIGNAL(triggered()), this, pluginSlot); return rc; } // Action to act on the repository forwarded to a git client member function // taking the directory. Store the member function as data on the action. ActionCommandPair GitPlugin::createRepositoryAction(Core::ActionContainer *ac, const QString &text, const Core::Id &id, const Core::Context &context, bool addToLocator, GitClientMemberFunc func) { // Set the member func as data and connect to generic slot const ActionCommandPair rc = createRepositoryAction(ac, text, id, context, addToLocator); rc.first->setData(qVariantFromValue(func)); connect(rc.first, SIGNAL(triggered()), this, SLOT(gitClientMemberFuncRepositoryAction())); return rc; } bool GitPlugin::initialize(const QStringList &arguments, QString *errorMessage) { Q_UNUSED(arguments) Q_UNUSED(errorMessage) m_settings.readSettings(Core::ICore::settings()); m_gitClient = new GitClient(&m_settings); typedef VcsBase::VcsEditorFactory GitEditorFactory; typedef VcsBase::VcsSubmitEditorFactory GitSubmitEditorFactory; initializeVcs(new GitVersionControl(m_gitClient)); // Create the globalcontext list to register actions accordingly Core::Context globalcontext(Core::Constants::C_GLOBAL); // Create the settings Page addAutoReleasedObject(new SettingsPage()); static const char *describeSlot = SLOT(show(QString,QString)); const int editorCount = sizeof(editorParameters)/sizeof(VcsBase::VcsBaseEditorParameters); for (int i = 0; i < editorCount; i++) addAutoReleasedObject(new GitEditorFactory(editorParameters + i, m_gitClient, describeSlot)); addAutoReleasedObject(new GitSubmitEditorFactory(&submitParameters)); addAutoReleasedObject(new CloneWizard); addAutoReleasedObject(new Gitorious::Internal::GitoriousCloneWizard); const QString description = QLatin1String("Git"); const QString prefix = QLatin1String("git"); m_commandLocator = new Locator::CommandLocator(description, prefix, prefix); addAutoReleasedObject(m_commandLocator); //register actions Core::ActionContainer *toolsContainer = Core::ActionManager::actionContainer(Core::Constants::M_TOOLS); Core::ActionContainer *gitContainer = Core::ActionManager::createMenu("Git"); gitContainer->menu()->setTitle(tr("&Git")); toolsContainer->addMenu(gitContainer); m_menuAction = gitContainer->menu()->menuAction(); ParameterActionCommandPair parameterActionCommand = createFileAction(gitContainer, tr("Blame Current File"), tr("Blame for \"%1\""), Core::Id("Git.Blame"), globalcontext, true, SLOT(blameFile())); parameterActionCommand.second->setDefaultKeySequence(QKeySequence(Core::UseMacShortcuts ? tr("Meta+G,Meta+B") : tr("Alt+G,Alt+B"))); parameterActionCommand = createFileAction(gitContainer, tr("Diff Current File"), tr("Diff of \"%1\""), Core::Id("Git.Diff"), globalcontext, true, SLOT(diffCurrentFile())); parameterActionCommand.second->setDefaultKeySequence(QKeySequence(Core::UseMacShortcuts ? tr("Meta+G,Meta+D") : tr("Alt+G,Alt+D"))); parameterActionCommand = createFileAction(gitContainer, tr("Log Current File"), tr("Log of \"%1\""), Core::Id("Git.Log"), globalcontext, true, SLOT(logFile())); parameterActionCommand.second->setDefaultKeySequence(QKeySequence(Core::UseMacShortcuts ? tr("Meta+G,Meta+L") : tr("Alt+G,Alt+L"))); // ------ gitContainer->addSeparator(globalcontext); parameterActionCommand = createFileAction(gitContainer, tr("Stage File for Commit"), tr("Stage \"%1\" for Commit"), Core::Id("Git.Stage"), globalcontext, true, SLOT(stageFile())); parameterActionCommand.second->setDefaultKeySequence(QKeySequence(Core::UseMacShortcuts ? tr("Meta+G,Meta+A") : tr("Alt+G,Alt+A"))); parameterActionCommand = createFileAction(gitContainer, tr("Unstage File from Commit"), tr("Unstage \"%1\" from Commit"), Core::Id("Git.Unstage"), globalcontext, true, SLOT(unstageFile())); parameterActionCommand = createFileAction(gitContainer, tr("Undo Unstaged Changes"), tr("Undo Unstaged Changes for \"%1\""), Core::Id("Git.UndoUnstaged"), globalcontext, true, SLOT(undoUnstagedFileChanges())); parameterActionCommand = createFileAction(gitContainer, tr("Undo Uncommitted Changes"), tr("Undo Uncommitted Changes for \"%1\""), Core::Id("Git.Undo"), globalcontext, true, SLOT(undoFileChanges())); parameterActionCommand.second->setDefaultKeySequence(QKeySequence(Core::UseMacShortcuts ? tr("Meta+G,Meta+U") : tr("Alt+G,Alt+U"))); // ------------ gitContainer->addSeparator(globalcontext); parameterActionCommand = createProjectAction(gitContainer, tr("Diff Current Project"), tr("Diff Project \"%1\""), Core::Id("Git.DiffProject"), globalcontext, true, SLOT(diffCurrentProject())); parameterActionCommand.second->setDefaultKeySequence(QKeySequence(Core::UseMacShortcuts ? tr("Meta+G,Meta+Shift+D") : tr("Alt+G,Alt+Shift+D"))); parameterActionCommand = createProjectAction(gitContainer, tr("Log Project"), tr("Log Project \"%1\""), Core::Id("Git.LogProject"), globalcontext, true, SLOT(logProject())); parameterActionCommand.second->setDefaultKeySequence(QKeySequence(Core::UseMacShortcuts ? tr("Meta+G,Meta+K") : tr("Alt+G,Alt+K"))); parameterActionCommand = createProjectAction(gitContainer, tr("Clean Project..."), tr("Clean Project \"%1\"..."), Core::Id("Git.CleanProject"), globalcontext, true, SLOT(cleanProject())); // -------------- gitContainer->addSeparator(globalcontext); createRepositoryAction(gitContainer, tr("Diff"), Core::Id("Git.DiffRepository"), globalcontext, true, SLOT(diffRepository())); createRepositoryAction(gitContainer, tr("Log"), Core::Id("Git.LogRepository"), globalcontext, true, &GitClient::graphLog); createRepositoryAction(gitContainer, tr("Status"), Core::Id("Git.StatusRepository"), globalcontext, true, &GitClient::status); createRepositoryAction(gitContainer, tr("Reset..."), Core::Id("Git.Reset"), globalcontext, false, SLOT(resetRepository())); createRepositoryAction(gitContainer, tr("Clean..."), Core::Id("Git.CleanRepository"), globalcontext, true, SLOT(cleanRepository())); m_createRepositoryAction = new QAction(tr("Create Repository..."), this); Core::Command *createRepositoryCommand = Core::ActionManager::registerAction(m_createRepositoryAction, "Git.CreateRepository", globalcontext); connect(m_createRepositoryAction, SIGNAL(triggered()), this, SLOT(createRepository())); gitContainer->addAction(createRepositoryCommand); // -------------- gitContainer->addSeparator(globalcontext); createRepositoryAction(gitContainer, tr("Launch gitk"), Core::Id("Git.LaunchGitK"), globalcontext, true, &GitClient::launchGitK); m_repositoryBrowserAction = createRepositoryAction(gitContainer, tr("Launch repository browser"), Core::Id("Git.LaunchRepositoryBrowser"), globalcontext, true, &GitClient::launchRepositoryBrowser).first; createRepositoryAction(gitContainer, tr("Branches..."), Core::Id("Git.BranchList"), globalcontext, true, SLOT(branchList())); createRepositoryAction(gitContainer, tr("Remotes..."), Core::Id("Git.RemoteList"), globalcontext, false, SLOT(remoteList())); m_showAction = new QAction(tr("Show..."), this); Core::Command *showCommitCommand = Core::ActionManager::registerAction(m_showAction, "Git.ShowCommit", globalcontext); connect(m_showAction, SIGNAL(triggered()), this, SLOT(showCommit())); gitContainer->addAction(showCommitCommand); // -------------- gitContainer->addSeparator(globalcontext); Core::ActionContainer *patchMenu = Core::ActionManager::createMenu(Core::Id("Git.PatchMenu")); patchMenu->menu()->setTitle(tr("Patch")); gitContainer->addMenu(patchMenu); // Apply current file as patch is handled specially. parameterActionCommand = createParameterAction(patchMenu, tr("Apply from Editor"), tr("Apply \"%1\""), Core::Id("Git.ApplyCurrentFilePatch"), globalcontext, true); m_applyCurrentFilePatchAction = parameterActionCommand.first; connect(m_applyCurrentFilePatchAction, SIGNAL(triggered()), this, SLOT(applyCurrentFilePatch())); createRepositoryAction(patchMenu, tr("Apply from File..."), Core::Id("Git.ApplyPatch"), globalcontext, true, SLOT(promptApplyPatch())); Core::ActionContainer *stashMenu = Core::ActionManager::createMenu(Core::Id("Git.StashMenu")); stashMenu->menu()->setTitle(tr("Stash")); gitContainer->addMenu(stashMenu); createRepositoryAction(stashMenu, tr("Stashes..."), Core::Id("Git.StashList"), globalcontext, false, SLOT(stashList())); stashMenu->addSeparator(globalcontext); ActionCommandPair actionCommand = createRepositoryAction(stashMenu, tr("Stash"), Core::Id("Git.Stash"), globalcontext, true, SLOT(stash())); actionCommand.first->setToolTip(tr("Saves the current state of your work and resets the repository.")); actionCommand = createRepositoryAction(stashMenu, tr("Take Snapshot..."), Core::Id("Git.StashSnapshot"), globalcontext, true, SLOT(stashSnapshot())); actionCommand.first->setToolTip(tr("Saves the current state of your work.")); stashMenu->addSeparator(globalcontext); actionCommand = createRepositoryAction(stashMenu, tr("Stash Pop"), Core::Id("Git.StashPop"), globalcontext, true, &GitClient::stashPop); actionCommand.first->setToolTip(tr("Restores changes saved to the stash list using \"Stash\".")); Core::ActionContainer *subversionMenu = Core::ActionManager::createMenu(Core::Id("Git.Subversion")); subversionMenu->menu()->setTitle(tr("Subversion")); gitContainer->addMenu(subversionMenu); createRepositoryAction(subversionMenu, tr("Log"), Core::Id("Git.Subversion.Log"), globalcontext, false, &GitClient::subversionLog); createRepositoryAction(subversionMenu, tr("Fetch"), Core::Id("Git.Subversion.Fetch"), globalcontext, false, &GitClient::synchronousSubversionFetch); gitContainer->addSeparator(globalcontext); gitContainer->addSeparator(globalcontext); createRepositoryAction(gitContainer, tr("Fetch"), Core::Id("Git.Fetch"), globalcontext, true, SLOT(fetch())); createRepositoryAction(gitContainer, tr("Pull"), Core::Id("Git.Pull"), globalcontext, true, SLOT(pull())); actionCommand = createRepositoryAction(gitContainer, tr("Push"), Core::Id("Git.Push"), globalcontext, true, SLOT(push())); actionCommand = createRepositoryAction(gitContainer, tr("Commit..."), Core::Id("Git.Commit"), globalcontext, true, SLOT(startCommit())); actionCommand.second->setDefaultKeySequence(QKeySequence(Core::UseMacShortcuts ? tr("Meta+G,Meta+C") : tr("Alt+G,Alt+C"))); createRepositoryAction(gitContainer, tr("Amend Last Commit..."), Core::Id("Git.AmendCommit"), globalcontext, true, SLOT(startAmendCommit())); // Subversion in a submenu. gitContainer->addSeparator(globalcontext); if (0) { const QList snapShotActions = createSnapShotTestActions(); const int count = snapShotActions.size(); for (int i = 0; i < count; i++) { Core::Command *tCommand = Core::ActionManager::registerAction(snapShotActions.at(i), Core::Id(QLatin1String("Git.Snapshot.") + QString::number(i)), globalcontext); gitContainer->addAction(tCommand); } } // Submit editor Core::Context submitContext(Constants::C_GITSUBMITEDITOR); m_submitCurrentAction = new QAction(VcsBase::VcsBaseSubmitEditor::submitIcon(), tr("Commit"), this); Core::Command *command = Core::ActionManager::registerAction(m_submitCurrentAction, Constants::SUBMIT_CURRENT, submitContext); command->setAttribute(Core::Command::CA_UpdateText); connect(m_submitCurrentAction, SIGNAL(triggered()), this, SLOT(submitCurrentLog())); m_diffSelectedFilesAction = new QAction(VcsBase::VcsBaseSubmitEditor::diffIcon(), tr("Diff &Selected Files"), this); command = Core::ActionManager::registerAction(m_diffSelectedFilesAction, Constants::DIFF_SELECTED, submitContext); m_undoAction = new QAction(tr("&Undo"), this); command = Core::ActionManager::registerAction(m_undoAction, Core::Constants::UNDO, submitContext); m_redoAction = new QAction(tr("&Redo"), this); command = Core::ActionManager::registerAction(m_redoAction, Core::Constants::REDO, submitContext); Gerrit::Internal::GerritPlugin *gp = new Gerrit::Internal::GerritPlugin(this); return gp->initialize(gitContainer); } GitVersionControl *GitPlugin::gitVersionControl() const { return static_cast(versionControl()); } void GitPlugin::submitEditorDiff(const QStringList &unstaged, const QStringList &staged) { m_gitClient->diff(m_submitRepository, QStringList(), unstaged, staged); } void GitPlugin::diffCurrentFile() { const VcsBase::VcsBasePluginState state = currentState(); QTC_ASSERT(state.hasFile(), return); m_gitClient->diff(state.currentFileTopLevel(), QStringList(), state.relativeCurrentFile()); } void GitPlugin::diffCurrentProject() { const VcsBase::VcsBasePluginState state = currentState(); QTC_ASSERT(state.hasProject(), return); m_gitClient->diff(state.currentProjectTopLevel(), QStringList(), state.relativeCurrentProject()); } void GitPlugin::diffRepository() { const VcsBase::VcsBasePluginState state = currentState(); QTC_ASSERT(state.hasTopLevel(), return); m_gitClient->diff(state.topLevel(), QStringList(), QStringList()); } void GitPlugin::logFile() { const VcsBase::VcsBasePluginState state = currentState(); QTC_ASSERT(state.hasFile(), return); m_gitClient->log(state.currentFileTopLevel(), QStringList(state.relativeCurrentFile()), true); } void GitPlugin::blameFile() { const VcsBase::VcsBasePluginState state = currentState(); QTC_ASSERT(state.hasFile(), return); const int lineNumber = VcsBase::VcsBaseEditorWidget::lineNumberOfCurrentEditor(state.currentFile()); m_gitClient->blame(state.currentFileTopLevel(), QStringList(), state.relativeCurrentFile(), QString(), lineNumber); } void GitPlugin::logProject() { const VcsBase::VcsBasePluginState state = currentState(); QTC_ASSERT(state.hasProject(), return); m_gitClient->log(state.currentProjectTopLevel(), state.relativeCurrentProject()); } void GitPlugin::undoFileChanges(bool revertStaging) { const VcsBase::VcsBasePluginState state = currentState(); QTC_ASSERT(state.hasFile(), return); Core::FileChangeBlocker fcb(state.currentFile()); m_gitClient->revert(QStringList(state.currentFile()), revertStaging); } void GitPlugin::undoUnstagedFileChanges() { undoFileChanges(false); } void GitPlugin::resetRepository() { const VcsBase::VcsBasePluginState state = currentState(); QTC_ASSERT(state.hasTopLevel(), return); ResetDialog dialog; if (dialog.runDialog(state.topLevel())) m_gitClient->hardReset(state.topLevel(), dialog.commit()); } void GitPlugin::stageFile() { const VcsBase::VcsBasePluginState state = currentState(); QTC_ASSERT(state.hasFile(), return); m_gitClient->addFile(state.currentFileTopLevel(), state.relativeCurrentFile()); } void GitPlugin::unstageFile() { const VcsBase::VcsBasePluginState state = currentState(); QTC_ASSERT(state.hasFile(), return); m_gitClient->synchronousReset(state.currentFileTopLevel(), QStringList(state.relativeCurrentFile())); } void GitPlugin::startAmendCommit() { startCommit(true); } void GitPlugin::startCommit() { startCommit(false); } void GitPlugin::startCommit(bool amend) { if (VcsBase::VcsBaseSubmitEditor::raiseSubmitEditor()) return; if (isCommitEditorOpen()) { VcsBase::VcsBaseOutputWindow::instance()->appendWarning(tr("Another submit is currently being executed.")); return; } const VcsBase::VcsBasePluginState state = currentState(); QTC_ASSERT(state.hasTopLevel(), return); QString errorMessage, commitTemplate; CommitData data; if (!m_gitClient->getCommitData(state.topLevel(), amend, &commitTemplate, &data, &errorMessage)) { VcsBase::VcsBaseOutputWindow::instance()->append(errorMessage); return; } // Store repository for diff and the original list of // files to be able to unstage files the user unchecks m_submitRepository = data.panelInfo.repository; m_commitAmendSHA1 = data.amendSHA1; // Start new temp file with message template Utils::TempFileSaver saver; // Keep the file alive, else it removes self and forgets its name saver.setAutoRemove(false); saver.write(commitTemplate.toLocal8Bit()); if (!saver.finalize()) { VcsBase::VcsBaseOutputWindow::instance()->append(saver.errorString()); return; } m_commitMessageFileName = saver.fileName(); openSubmitEditor(m_commitMessageFileName, data, amend); } Core::IEditor *GitPlugin::openSubmitEditor(const QString &fileName, const CommitData &cd, bool amend) { Core::IEditor *editor = Core::EditorManager::openEditor(fileName, Constants::GITSUBMITEDITOR_ID, Core::EditorManager::ModeSwitch); GitSubmitEditor *submitEditor = qobject_cast(editor); QTC_ASSERT(submitEditor, return 0); // The actions are for some reason enabled by the context switching // mechanism. Disable them correctly. submitEditor->registerActions(m_undoAction, m_redoAction, m_submitCurrentAction, m_diffSelectedFilesAction); submitEditor->setCommitData(cd); submitEditor->setCheckScriptWorkingDirectory(m_submitRepository); const QString title = amend ? tr("Amend %1").arg(cd.amendSHA1) : tr("Git Commit"); submitEditor->setDisplayName(title); if (amend) // Allow for just correcting the message submitEditor->setEmptyFileListEnabled(true); connect(submitEditor, SIGNAL(diff(QStringList,QStringList)), this, SLOT(submitEditorDiff(QStringList,QStringList))); return editor; } void GitPlugin::submitCurrentLog() { // Close the submit editor m_submitActionTriggered = true; Core::ICore::editorManager()->closeEditor(); } bool GitPlugin::submitEditorAboutToClose(VcsBase::VcsBaseSubmitEditor *submitEditor) { if (!isCommitEditorOpen()) return false; Core::IDocument *editorDocument = submitEditor->document(); const GitSubmitEditor *editor = qobject_cast(submitEditor); if (!editorDocument || !editor) return true; // Submit editor closing. Make it write out the commit message // and retrieve files const QFileInfo editorFile(editorDocument->fileName()); const QFileInfo changeFile(m_commitMessageFileName); // Paranoia! if (editorFile.absoluteFilePath() != changeFile.absoluteFilePath()) return true; // Prompt user. Force a prompt unless submit was actually invoked (that // is, the editor was closed or shutdown). bool *promptData = m_settings.boolPointer(GitSettings::promptOnSubmitKey); const VcsBase::VcsBaseSubmitEditor::PromptSubmitResult answer = editor->promptSubmit(tr("Closing Git Editor"), tr("Do you want to commit the change?"), tr("Git will not accept this commit. Do you want to continue to edit it?"), promptData, !m_submitActionTriggered, false); m_submitActionTriggered = false; switch (answer) { case VcsBase::VcsBaseSubmitEditor::SubmitCanceled: return false; // Keep editing and change file case VcsBase::VcsBaseSubmitEditor::SubmitDiscarded: cleanCommitMessageFile(); return true; // Cancel all default: break; } // Go ahead! VcsBase::SubmitFileModel *model = qobject_cast(editor->fileModel()); bool closeEditor = true; if (model->hasCheckedFiles() || !m_commitAmendSHA1.isEmpty()) { // get message & commit if (!Core::DocumentManager::saveDocument(editorDocument)) return false; closeEditor = m_gitClient->addAndCommit(m_submitRepository, editor->panelData(), m_commitAmendSHA1, m_commitMessageFileName, model); } if (closeEditor) cleanCommitMessageFile(); return closeEditor; } void GitPlugin::fetch() { m_gitClient->synchronousFetch(currentState().topLevel(), QString()); } void GitPlugin::pull() { const VcsBase::VcsBasePluginState state = currentState(); QTC_ASSERT(state.hasTopLevel(), return); const bool rebase = m_gitClient->settings()->boolValue(GitSettings::pullRebaseKey); GitClient::StashResult stashResult = m_gitClient->ensureStash(state.topLevel()); switch (stashResult) { case GitClient::StashUnchanged: case GitClient::Stashed: m_gitClient->synchronousPull(state.topLevel(), rebase); if (stashResult == GitClient::Stashed) m_gitClient->stashPop(state.topLevel()); break; case GitClient::NotStashed: if (!rebase) m_gitClient->synchronousPull(state.topLevel(), false); break; default: break; } } void GitPlugin::push() { const VcsBase::VcsBasePluginState state = currentState(); QTC_ASSERT(state.hasTopLevel(), return); m_gitClient->synchronousPush(state.topLevel()); } // Retrieve member function of git client stored as user data of action static inline GitClientMemberFunc memberFunctionFromAction(const QObject *o) { if (o) { if (const QAction *action = qobject_cast(o)) { const QVariant v = action->data(); if (qVariantCanConvert(v)) return qVariantValue(v); } } return 0; } void GitPlugin::gitClientMemberFuncRepositoryAction() { const VcsBase::VcsBasePluginState state = currentState(); QTC_ASSERT(state.hasTopLevel(), return); // Retrieve member function and invoke on repository GitClientMemberFunc func = memberFunctionFromAction(sender()); QTC_ASSERT(func, return); (m_gitClient->*func)(state.topLevel()); } void GitPlugin::cleanProject() { const VcsBase::VcsBasePluginState state = currentState(); QTC_ASSERT(state.hasProject(), return); cleanRepository(state.currentProjectPath()); } void GitPlugin::cleanRepository() { const VcsBase::VcsBasePluginState state = currentState(); QTC_ASSERT(state.hasTopLevel(), return); cleanRepository(state.topLevel()); } void GitPlugin::cleanRepository(const QString &directory) { // Find files to be deleted QString errorMessage; QStringList files; QStringList ignoredFiles; QApplication::setOverrideCursor(Qt::WaitCursor); const bool gotFiles = m_gitClient->synchronousCleanList(directory, &files, &ignoredFiles, &errorMessage); QApplication::restoreOverrideCursor(); QWidget *parent = Core::ICore::mainWindow(); if (!gotFiles) { QMessageBox::warning(parent, tr("Unable to retrieve file list"), errorMessage); return; } if (files.isEmpty() && ignoredFiles.isEmpty()) { QMessageBox::information(parent, tr("Repository Clean"), tr("The repository is clean.")); return; } // Show in dialog VcsBase::CleanDialog dialog(parent); dialog.setFileList(directory, files, ignoredFiles); dialog.exec(); } // If the file is modified in an editor, make sure it is saved. static bool ensureFileSaved(const QString &fileName) { const QList editors = Core::EditorManager::instance()->editorsForFileName(fileName); if (editors.isEmpty()) return true; Core::IDocument *document = editors.front()->document(); if (!document || !document->isModified()) return true; bool canceled; QList documents; documents << document; Core::DocumentManager::saveModifiedDocuments(documents, &canceled); return !canceled; } void GitPlugin::applyCurrentFilePatch() { const VcsBase::VcsBasePluginState state = currentState(); QTC_ASSERT(state.hasPatchFile() && state.hasTopLevel(), return); const QString patchFile = state.currentPatchFile(); if (!ensureFileSaved(patchFile)) return; applyPatch(state.topLevel(), patchFile); } void GitPlugin::promptApplyPatch() { const VcsBase::VcsBasePluginState state = currentState(); QTC_ASSERT(state.hasTopLevel(), return); applyPatch(state.topLevel(), QString()); } void GitPlugin::applyPatch(const QString &workingDirectory, QString file) { // Ensure user has been notified about pending changes switch (m_gitClient->ensureStash(workingDirectory)) { case GitClient::StashUnchanged: case GitClient::Stashed: case GitClient::NotStashed: break; default: return; } // Prompt for file if (file.isEmpty()) { const QString filter = tr("Patches (*.patch *.diff)"); file = QFileDialog::getOpenFileName(Core::ICore::mainWindow(), tr("Choose Patch"), QString(), filter); if (file.isEmpty()) return; } // Run! VcsBase::VcsBaseOutputWindow *outwin = VcsBase::VcsBaseOutputWindow::instance(); QString errorMessage; if (m_gitClient->synchronousApplyPatch(workingDirectory, file, &errorMessage)) { if (errorMessage.isEmpty()) { outwin->append(tr("Patch %1 successfully applied to %2").arg(file, workingDirectory)); } else { outwin->append(errorMessage); } } else { outwin->appendError(errorMessage); } } void GitPlugin::stash() { // Simple stash without prompt, reset repo. const VcsBase::VcsBasePluginState state = currentState(); QTC_ASSERT(state.hasTopLevel(), return); const QString id = m_gitClient->synchronousStash(state.topLevel(), QString(), 0); if (!id.isEmpty() && m_stashDialog) m_stashDialog->refresh(state.topLevel(), true); } void GitPlugin::stashSnapshot() { // Prompt for description, restore immediately and keep on working. const VcsBase::VcsBasePluginState state = currentState(); QTC_ASSERT(state.hasTopLevel(), return); const QString id = m_gitClient->synchronousStash(state.topLevel(), QString(), GitClient::StashImmediateRestore|GitClient::StashPromptDescription); if (!id.isEmpty() && m_stashDialog) m_stashDialog->refresh(state.topLevel(), true); } // Create a non-modal dialog with refresh method or raise if it exists template inline void showNonModalDialog(const QString &topLevel, QPointer &dialog) { if (dialog) { dialog->show(); dialog->raise(); } else { dialog = new NonModalDialog(Core::ICore::mainWindow()); dialog->refresh(topLevel, true); dialog->show(); } } void GitPlugin::branchList() { showNonModalDialog(currentState().topLevel(), m_branchDialog); } void GitPlugin::remoteList() { showNonModalDialog(currentState().topLevel(), m_remoteDialog); } void GitPlugin::stashList() { showNonModalDialog(currentState().topLevel(), m_stashDialog); } void GitPlugin::updateActions(VcsBase::VcsBasePlugin::ActionState as) { const bool repositoryEnabled = currentState().hasTopLevel(); if (m_stashDialog) m_stashDialog->refresh(currentState().topLevel(), false); if (m_branchDialog) m_branchDialog->refresh(currentState().topLevel(), false); if (m_remoteDialog) m_remoteDialog->refresh(currentState().topLevel(), false); m_commandLocator->setEnabled(repositoryEnabled); if (!enableMenuAction(as, m_menuAction)) return; // Note: This menu is visible if there is no repository. Only // 'Create Repository'/'Show' actions should be available. const QString fileName = currentState().currentFileName(); foreach (Utils::ParameterAction *fileAction, m_fileActions) fileAction->setParameter(fileName); // If the current file looks like a patch, offer to apply m_applyCurrentFilePatchAction->setParameter(currentState().currentPatchFileDisplayName()); const QString projectName = currentState().currentProjectName(); foreach (Utils::ParameterAction *projectAction, m_projectActions) projectAction->setParameter(projectName); foreach (QAction *repositoryAction, m_repositoryActions) repositoryAction->setEnabled(repositoryEnabled); updateRepositoryBrowserAction(); // Prompts for repo. m_showAction->setEnabled(true); } void GitPlugin::updateRepositoryBrowserAction() { const bool repositoryEnabled = currentState().hasTopLevel(); const bool hasRepositoryBrowserCmd = !settings().stringValue(GitSettings::repositoryBrowserCmd).isEmpty(); m_repositoryBrowserAction->setEnabled(repositoryEnabled && hasRepositoryBrowserCmd); } void GitPlugin::showCommit() { const VcsBase::VcsBasePluginState state = currentState(); if (!m_changeSelectionDialog) m_changeSelectionDialog = new ChangeSelectionDialog(); if (state.hasFile()) m_changeSelectionDialog->setWorkingDirectory(state.currentFileDirectory()); else if (state.hasTopLevel()) m_changeSelectionDialog->setWorkingDirectory(state.topLevel()); if (m_changeSelectionDialog->exec() != QDialog::Accepted) return; const QString change = m_changeSelectionDialog->change(); if (change.isEmpty()) return; m_gitClient->show(m_changeSelectionDialog->workingDirectory(), change); } const GitSettings &GitPlugin::settings() const { return m_settings; } void GitPlugin::setSettings(const GitSettings &s) { if (s == m_settings) return; m_settings = s; m_gitClient->saveSettings(); static_cast(versionControl())->emitConfigurationChanged(); updateRepositoryBrowserAction(); } GitClient *GitPlugin::gitClient() const { return m_gitClient; } Q_EXPORT_PLUGIN(GitPlugin)