comparison mainwindow.cpp @ 336:4229b6a8e9c6

Merge

 #include "logparser.h"
 #include "confirmcommentdialog.h"
 #include "incomingdialog.h"
 #include "settingsdialog.h"
 #include "moreinformationdialog.h"
+#include "annotatedialog.h"
 #include "version.h"
 #include "workstatuswidget.h"
 
 
 MainWindow::MainWindow(QString myDirPath) :

     QStringList params;
     params << "parents";
     m_runner->requestAction(HgAction(ACT_QUERY_PARENTS, m_workFolderPath, params));
 }
 
-void MainWindow::hgAnnotate()
-{
-    QStringList params;
-    QString currentFile;//!!! = m_hgTabs -> getCurrentFileListLine();
+void MainWindow::hgAnnotateFiles(QStringList files)
+{
+    QStringList params;
     
-    if (!currentFile.isEmpty())
-    {
-        params << "annotate" << "--" << currentFile.mid(2);   //Jump over status marker characters (e.g "M ")
-
+    if (!files.isEmpty()) {
+        params << "annotate" << "-udqc" << "--" << files;
         m_runner->requestAction(HgAction(ACT_ANNOTATE, m_workFolderPath, params));
     }
 }
 
 void MainWindow::hgResolveList()

     m_runner->requestAction(HgAction(ACT_RESOLVE_LIST, m_workFolderPath, params));
 }
 
 void MainWindow::hgAdd()
 {
-    QStringList params;
-
     // hgExplorer permitted adding "all" files -- I'm not sure
     // that one is a good idea, let's require the user to select
 
-    QStringList files = m_hgTabs->getSelectedAddableFiles();
+    hgAddFiles(m_hgTabs->getSelectedAddableFiles());
+}
+
+void MainWindow::hgAddFiles(QStringList files)
+{
+    QStringList params;
 
     if (!files.empty()) {
         params << "add" << "--" << files;
         m_runner->requestAction(HgAction(ACT_ADD, m_workFolderPath, params));
     }
 }
 
-
 void MainWindow::hgRemove()
 {
-    QStringList params;
-
-    QStringList files = m_hgTabs->getSelectedRemovableFiles();
+    hgRemoveFiles(m_hgTabs->getSelectedRemovableFiles());
+}
+
+void MainWindow::hgRemoveFiles(QStringList files)
+{
+    QStringList params;
 
     if (!files.empty()) {
         params << "remove" << "--after" << "--force" << "--" << files;
         m_runner->requestAction(HgAction(ACT_REMOVE, m_workFolderPath, params));
     }
 }
 
 void MainWindow::hgCommit()
 {
+    hgCommitFiles(QStringList());
+}
+
+void MainWindow::hgCommitFiles(QStringList files)
+{
     QStringList params;
     QString comment;
 
     if (m_justMerged) {
         comment = m_mergeCommitComment;
     }
 
-    QStringList files = m_hgTabs->getSelectedCommittableFiles();
     QStringList allFiles = m_hgTabs->getAllCommittableFiles();
     QStringList reportFiles = files;
     if (reportFiles.empty()) {
         reportFiles = allFiles;
     }

             m_runner->requestAction(HgAction(ACT_NEW_BRANCH, m_workFolderPath, params));
         }
     }
 }
 
-
 void MainWindow::hgNoBranch()
 {
     if (m_currentParents.empty()) return;
 
     QString parentBranch = m_currentParents[0]->branch();

 
     QStringList params;
     params << "branch" << parentBranch;
     m_runner->requestAction(HgAction(ACT_NEW_BRANCH, m_workFolderPath, params));
 }
-
 
 void MainWindow::hgTag(QString id)
 {
     QStringList params;
     QString tag;

             
             m_runner->requestAction(HgAction(ACT_TAG, m_workFolderPath, params));
         }
     }
 }
-
 
 void MainWindow::hgIgnore()
 {
     QString hgIgnorePath;
     QStringList params;

     action.executable = editor;
 
     m_runner->requestAction(action);
 }
 
+void MainWindow::hgIgnoreFiles(QStringList files)
+{
+    //!!! not implemented yet
+    DEBUG << "MainWindow::hgIgnoreFiles: Not implemented" << endl;
+}
+
+void MainWindow::hgUnIgnoreFiles(QStringList files)
+{
+    //!!! not implemented yet
+    DEBUG << "MainWindow::hgUnIgnoreFiles: Not implemented" << endl;
+}
+
 QString MainWindow::getDiffBinaryName()
 {
     QSettings settings;
     settings.beginGroup("Locations");
     return settings.value("extdiffbinary", "").toString();

     m_runner->requestAction(HgAction(ACT_UNCOMMITTED_SUMMARY, m_workFolderPath, params));
 }
 
 void MainWindow::hgFolderDiff()
 {
+    hgDiffFiles(QStringList());
+}
+
+void MainWindow::hgDiffFiles(QStringList files)
+{
     QString diff = getDiffBinaryName();
     if (diff == "") return;
 
     QStringList params;
 
     // Diff parent against working folder (folder diff)
 
     params << "--config" << "extensions.extdiff=" << "extdiff";
     params << "--program" << diff;
 
-    params << m_hgTabs->getSelectedCommittableFiles(); // may be none: whole dir
+    params << "--" << files; // may be none: whole dir
 
     m_runner->requestAction(HgAction(ACT_FOLDERDIFF, m_workFolderPath, params));
 }
-
 
 void MainWindow::hgDiffToCurrent(QString id)
 {
     QString diff = getDiffBinaryName();
     if (diff == "") return;

     params << "--program" << diff;
     params << "--rev" << Changeset::hashOf(id);
 
     m_runner->requestAction(HgAction(ACT_FOLDERDIFF, m_workFolderPath, params));
 }
-
 
 void MainWindow::hgDiffToParent(QString child, QString parent)
 {
     QString diff = getDiffBinaryName();
     if (diff == "") return;

     params << "--rev" << Changeset::hashOf(parent)
            << "--rev" << Changeset::hashOf(child);
 
     m_runner->requestAction(HgAction(ACT_CHGSETDIFF, m_workFolderPath, params));
 }
-
+    
 
 void MainWindow::hgShowSummaryFor(Changeset *cs)
 {
     QStringList params;
 

 }
 
 
 void MainWindow::hgRevert()
 {
+    hgRevertFiles(QStringList());
+}
+
+void MainWindow::hgRevertFiles(QStringList files)
+{
     QStringList params;
     QString comment;
     bool all = false;
 
-    QStringList files = m_hgTabs->getSelectedRevertableFiles();
     QStringList allFiles = m_hgTabs->getAllRevertableFiles();
     if (files.empty() || files == allFiles) {
         files = allFiles;
         all = true;
     }

         m_runner->requestAction(HgAction(ACT_REVERT, m_workFolderPath, params));
     }
 }
 
 
-void MainWindow::hgMarkResolved(QStringList files)
+void MainWindow::hgMarkFilesResolved(QStringList files)
 {
     QStringList params;
 
     params << "resolve" << "--mark";
 

 
     m_runner->requestAction(HgAction(ACT_RESOLVE_MARK, m_workFolderPath, params));
 }
 
 
-void MainWindow::hgRetryMerge()
+void MainWindow::hgRedoMerge()
+{
+    hgRedoFileMerges(QStringList());
+}
+
+
+void MainWindow::hgRedoFileMerges(QStringList files)
 {
     QStringList params;
 
     params << "resolve";
 
     QString merge = getMergeBinaryName();
     if (merge != "") {
         params << "--tool" << merge;
     }
 
-    QStringList files = m_hgTabs->getSelectedUnresolvedFiles();
     if (files.empty()) {
         params << "--all";
     } else {
         params << "--" << files;
     }

 
     m_runner->requestAction(HgAction(ACT_RETRY_MERGE, m_workFolderPath, params));
 
     m_mergeCommitComment = tr("Merge");
 }
-
+    
 
 void MainWindow::hgMerge()
 {
     if (m_hgTabs->canResolve()) {
-        hgRetryMerge();
+        hgRedoMerge();
         return;
     }
 
     QStringList params;
 

         updateToolBarStyle();
         hgRefresh();
     }
 }
 
-#define STDOUT_NEEDS_BIG_WINDOW 512
-#define SMALL_WND_W     500
-#define SMALL_WND_H     300
-
-#define BIG_WND_W       1024
-#define BIG_WND_H       768
-
-
-void MainWindow::presentLongStdoutToUser(QString stdo)
-{
-    if (!stdo.isEmpty())
-    {
-        QDialog dlg;
-
-        if (stdo.length() > STDOUT_NEEDS_BIG_WINDOW)
-        {
-            dlg.setMinimumWidth(BIG_WND_W);
-            dlg.setMinimumHeight(BIG_WND_H);
-        }
-        else
-        {
-            dlg.setMinimumWidth(SMALL_WND_W);
-            dlg.setMinimumHeight(SMALL_WND_H);
-        }
-
-        QVBoxLayout *box = new QVBoxLayout;
-        QListWidget *list = new QListWidget;
-        list-> addItems(stdo.split("\n"));
-        QPushButton *btn = new QPushButton(tr("Ok"));
-        connect(btn, SIGNAL(clicked()), &dlg, SLOT(accept()));
-
-        box -> addWidget(list);
-        box -> addWidget(btn);
-        dlg.setLayout(box);
-
-        dlg.exec();
-    }
-    else
-    {
-        QMessageBox::information(this, tr("EasyMercurial"), tr("Mercurial command did not return any output."));
-    }
-}
-
 void MainWindow::updateFileSystemWatcher()
 {
     bool justCreated = false;
     if (!m_fsWatcher) {
         m_fsWatcher = new QFileSystemWatcher();

     QString head;
     QString report;
     int n = extractChangeCount(output);
     if (n > 0) {
         head = tr("Pulled %n changeset(s)", "", n);
-        report = tr("The new changes will be highlighted in the history.<br>Use Update to bring these changes into your working copy.");
+        report = tr("New changes will be highlighted in yellow in the history.");
     } else if (n == 0) {
         head = tr("No changes to pull");
         report = tr("Your local repository already contains all changes found in the remote repository.");
     } else {
         head = tr("Pull complete");

         return;
     case ACT_CLONEFROMREMOTE:
         // if clone fails, we have no repo
         m_workFolderPath = "";
         enableDisableActions();
-        break;
+        break; // go on to default report
     case ACT_INCOMING:
         // returns non-zero code and no output if the check was
         // successful but there are no changes pending
         if (output.replace(QRegExp("(^|\\n)warning: [^\\n]*\\n"), "").trimmed() == "") {
             showIncoming("");
             return;
         }
-        break;
+        break; // go on to default report
     case ACT_QUERY_HEADS:
         // fails if repo is empty; we don't care (if there's a genuine
         // problem, something else will fail too).  Pretend it
         // succeeded, so that any further actions that are contingent
         // on the success of the heads query get carried out properly.

     case ACT_PUSH:
         if (output.contains("creates new remote heads")) {
             reportNewRemoteHeads(output);
             return;
         }
+        break; // go on to default report
+    case ACT_MERGE:
+    case ACT_RETRY_MERGE:
+        MoreInformationDialog::information
+            (this, tr("Merge"), tr("Merge failed"),
+             tr("Some files were not merged successfully.<p>You can Merge again to repeat the interactive merge; use Revert to abandon the merge entirely; or edit the files that are in conflict in an editor and, when you are happy with them, choose Mark Resolved in each file's right-button menu."),
+             output);
+        return;
     case ACT_STAT:
-        break; // go on and report
+        break; // go on to default report
     default:
         break;
     }
 
     QString command = action.executable;

     case ACT_INCOMING:
         showIncoming(output);
         break;
 
     case ACT_ANNOTATE:
-        presentLongStdoutToUser(output);
+    {
+        AnnotateDialog dialog(this, output);
+        dialog.exec();
         m_shouldHgStat = true;
         break;
+    }
         
     case ACT_PULL:
         showPullResult(output);
         m_shouldHgStat = true;
         break;

         m_justMerged = false;
         m_shouldHgStat = true;
         break;
 
     case ACT_REVERT:
-        hgMarkResolved(m_lastRevertedFiles);
+        hgMarkFilesResolved(m_lastRevertedFiles);
         m_justMerged = false;
         break;
         
     case ACT_REMOVE:
     case ACT_ADD:

 
     connect(m_hgIncomingAct, SIGNAL(triggered()), this, SLOT(hgIncoming()));
     connect(m_hgPullAct, SIGNAL(triggered()), this, SLOT(hgPull()));
     connect(m_hgPushAct, SIGNAL(triggered()), this, SLOT(hgPush()));
 
-    connect(m_hgAnnotateAct, SIGNAL(triggered()), this, SLOT(hgAnnotate()));
     connect(m_hgServeAct, SIGNAL(triggered()), this, SLOT(hgServe()));
 }
 
 void MainWindow::connectTabsSignals()
 {
+    connect(m_hgTabs, SIGNAL(currentChanged(int)),
+            this, SLOT(enableDisableActions()));
+
     connect(m_hgTabs, SIGNAL(commit()),
             this, SLOT(hgCommit()));
     
     connect(m_hgTabs, SIGNAL(revert()),
             this, SLOT(hgRevert()));

     connect(m_hgTabs, SIGNAL(newBranch(QString)),
             this, SLOT(hgNewBranch()));
 
     connect(m_hgTabs, SIGNAL(tag(QString)),
             this, SLOT(hgTag(QString)));
+
+    connect(m_hgTabs, SIGNAL(annotateFiles(QStringList)),
+            this, SLOT(hgAnnotateFiles(QStringList)));
+
+    connect(m_hgTabs, SIGNAL(diffFiles(QStringList)),
+            this, SLOT(hgDiffFiles(QStringList)));
+
+    connect(m_hgTabs, SIGNAL(commitFiles(QStringList)),
+            this, SLOT(hgCommitFiles(QStringList)));
+
+    connect(m_hgTabs, SIGNAL(revertFiles(QStringList)),
+            this, SLOT(hgRevertFiles(QStringList)));
+
+    connect(m_hgTabs, SIGNAL(addFiles(QStringList)),
+            this, SLOT(hgAddFiles(QStringList)));
+
+    connect(m_hgTabs, SIGNAL(removeFiles(QStringList)),
+            this, SLOT(hgRemoveFiles(QStringList)));
+
+    connect(m_hgTabs, SIGNAL(redoFileMerges(QStringList)),
+            this, SLOT(hgRedoFileMerges(QStringList)));
+
+    connect(m_hgTabs, SIGNAL(markFilesResolved(QStringList)),
+            this, SLOT(hgMarkFilesResolved(QStringList)));
+
+    connect(m_hgTabs, SIGNAL(ignoreFiles(QStringList)),
+            this, SLOT(hgIgnoreFiles(QStringList)));
+
+    connect(m_hgTabs, SIGNAL(unIgnoreFiles(QStringList)),
+            this, SLOT(hgUnIgnoreFiles(QStringList)));
 }    
 
 void MainWindow::enableDisableActions()
 {
     DEBUG << "MainWindow::enableDisableActions" << endl;

     m_hgAddAct -> setEnabled(m_localRepoActionsEnabled);
     m_hgRemoveAct -> setEnabled(m_localRepoActionsEnabled);
     m_hgUpdateAct -> setEnabled(m_localRepoActionsEnabled);
     m_hgCommitAct -> setEnabled(m_localRepoActionsEnabled);
     m_hgMergeAct -> setEnabled(m_localRepoActionsEnabled);
-    m_hgAnnotateAct -> setEnabled(m_localRepoActionsEnabled);
     m_hgServeAct -> setEnabled(m_localRepoActionsEnabled);
     m_hgIgnoreAct -> setEnabled(m_localRepoActionsEnabled);
 
     DEBUG << "m_localRepoActionsEnabled = " << m_localRepoActionsEnabled << endl;
     DEBUG << "canCommit = " << m_hgTabs->canCommit() << endl;

 
     m_hgMergeAct = new QAction(QIcon(":/images/merge.png"), tr("Merge"), this);
     m_hgMergeAct->setStatusTip(tr("Merge the two independent sets of changes in the local repository into the working folder"));
 
     //Advanced actions
-    //!!! needs to be modified for number
-    m_hgAnnotateAct = new QAction(tr("Annotate"), this);
-    m_hgAnnotateAct -> setStatusTip(tr("Show line-by-line version information for selected file"));
 
     m_hgIgnoreAct = new QAction(tr("Edit .hgignore File"), this);
     m_hgIgnoreAct -> setStatusTip(tr("Edit the .hgignore file, containing the names of files that should be ignored by Mercurial"));
 
     m_hgServeAct = new QAction(tr("Serve via HTTP"), this);