comparison mainwindow.cpp @ 163:5c262ac73948

* First cut of work on merge/resolve logic

 {
     QString wndTitle;
 
     fsWatcher = 0;
     commitsSincePush = 0;
+    shouldHgStat = true;
 
     createActions();
     createMenus();
     createToolBars();
     createStatusBar();

     if (firstStart) {
         startupDialog();
     }
 
     findDiffBinaryName();
+    findMergeBinaryName();
 
     ColourSet *cs = ColourSet::instance();
     cs->clearDefaultNames();
     cs->addDefaultName("");
     cs->addDefaultName("default");

 void MainWindow::hgStat()
 {
     QStringList params;
     params << "stat" << "-ardum";
 
+    lastStatOutput = "";
+
     // annoyingly, hg stat actually modifies the working directory --
     // it creates files called hg-checklink and hg-checkexec to test
     // properties of the filesystem
     if (fsWatcher) fsWatcher->blockSignals(true);
 

     if (!currentFile.isEmpty())
     {
         params << "annotate" << "--" << currentFile.mid(2);   //Jump over status marker characters (e.g "M ")
 
         runner->requestAction(HgAction(ACT_ANNOTATE, workFolderPath, params));
-    }
-}
-
-void MainWindow::hgResolveMark()
-{
-    QStringList params;
-    QString currentFile;//!!! = hgTabs -> getCurrentFileListLine();
-
-    if (!currentFile.isEmpty())
-    {
-        params << "resolve" << "--mark" << "--" << currentFile.mid(2);   //Jump over status marker characters (e.g "M ")
-
-        runner->requestAction(HgAction(ACT_RESOLVE_MARK, workFolderPath, params));
     }
 }
 
 void MainWindow::hgResolveList()
 {

                    << "--user" << getUserInfo();
         }
         
         runner->requestAction(HgAction(ACT_COMMIT, workFolderPath, params));
     }
-    
-    justMerged = false;
 }
 
 QString MainWindow::filterTag(QString tag)
 {
     for(int i = 0; i < tag.size(); i++)

         }
     }
     diffBinaryName = diff;
 }
 
+void MainWindow::findMergeBinaryName()
+{
+    QSettings settings;
+    QString merge = settings.value("mergebinary", "").toString();
+    if (merge == "") {
+        QStringList bases;
+        bases << "fmdiff3" << "kdiff3" << "meld" << "diffuse";
+        bool found = false;
+        foreach (QString base, bases) {
+            merge = findExecutable(base);
+            if (merge != base) {
+                found = true;
+                break;
+            }
+        }
+        if (found) {
+            settings.setValue("mergebinary", merge);
+        } else {
+            merge = "";
+        }
+    }
+    mergeBinaryName = merge;
+}
+
 void MainWindow::hgFolderDiff()
 {
     if (diffBinaryName == "") return;
 
     QStringList params;

 }
 
 
 void MainWindow::hgDiffToCurrent(QString id)
 {
+    if (diffBinaryName == "") return;
+
     QStringList params;
 
     // Diff given revision against working folder
 
     params << "--config" << "extensions.extdiff=" << "extdiff";

 }
 
 
 void MainWindow::hgDiffToParent(QString child, QString parent)
 {
+    if (diffBinaryName == "") return;
+
     QStringList params;
 
     // Diff given revision against working folder
 
     params << "--config" << "extensions.extdiff=" << "extdiff";

          tr("<h3>%1</h3><p>%2").arg(rf)
          .arg(tr("You are about to <b>revert</b> the following files to their previous committed state.<br><br>This will <b>throw away any changes</b> that you have made to these files but have not committed:")),
          tr("<h3>%1</h3><p>%2").arg(rf)
          .arg(tr("You are about to <b>revert</b> %n file(s).<br><br>This will <b>throw away any changes</b> that you have made to these files but have not committed.", "", files.size())),
          files)) {
+
+        lastRevertedFiles = files;
         
         if (files.empty()) {
             params << "revert" << "--no-backup";
         } else {
             params << "revert" << "--no-backup" << "--" << files;
         }
+
+        //!!! This is problematic.  If you've got an uncommitted
+        //!!! merge, you can't revert it without declaring which
+        //!!! parent of the merge you want to revert to (reasonably
+        //!!! enough).  We're OK if we just did the merge in easyhg a
+        //!!! moment ago, because we have a record of which parent was
+        //!!! the target -- but if you exit and restart, we've lost
+        //!!! that record and it doesn't appear to be possible to get
+        //!!! it back from Hg.  Even if you just switched from one
+        //!!! repo to another, the record is lost.  What to do?
+
+        if (justMerged && mergeTargetRevision != "") {
+            params << "--rev" << mergeTargetRevision;
+        }
         
         runner->requestAction(HgAction(ACT_REVERT, workFolderPath, params));
     }
 }
 
+
+void MainWindow::hgMarkResolved(QStringList files)
+{
+    QStringList params;
+
+    params << "resolve" << "--mark";
+
+    if (files.empty()) {
+        params << "--all";
+    } else {
+        params << files;
+    }
+
+    runner->requestAction(HgAction(ACT_RESOLVE_MARK, workFolderPath, params));
+}
+
+
 void MainWindow::hgRetryMerge()
 {
     QStringList params;
 
-    params << "resolve" << "--all";
+    params << "resolve";
+
+    if (mergeBinaryName != "") {
+        params << "--tool" << mergeBinaryName;
+    }
+
+    QStringList files = hgTabs->getSelectedUnresolvedFiles();
+    if (files.empty()) {
+        params << "--all";
+    } else {
+        params << files;
+    }
+
     runner->requestAction(HgAction(ACT_RETRY_MERGE, workFolderPath, params));
+
+    mergeCommitComment = tr("Merge");
 }
 
 
 void MainWindow::hgMerge()
 {
+    if (hgTabs->canResolve()) {
+        hgRetryMerge();
+        return;
+    }
+
     QStringList params;
 
     params << "merge";
-    
+
+    if (mergeBinaryName != "") {
+        params << "--tool" << mergeBinaryName;
+    }
+
+    if (currentParents.size() == 1) {
+        mergeTargetRevision = currentParents[0]->id();
+    }
+
     runner->requestAction(HgAction(ACT_MERGE, workFolderPath, params));
 
     mergeCommitComment = tr("Merge");
 }
 

 {
     QStringList params;
 
     params << "merge";
     params << "--rev" << Changeset::hashOf(id);
+
+    if (mergeBinaryName != "") {
+        params << "--tool" << mergeBinaryName;
+    }
     
     runner->requestAction(HgAction(ACT_MERGE, workFolderPath, params));
 
     mergeCommitComment = "";
 

     foreach (Changeset *cs, currentParents) delete cs;
     currentParents.clear();
     foreach (Changeset *cs, currentHeads) delete cs;
     currentHeads.clear();
     currentBranch = "";
+    lastStatOutput = "";
+    lastRevertedFiles.clear();
+    mergeTargetRevision = "";
+    mergeCommitComment = "";
     needNewLog = true;
 }
 
 void MainWindow::hgServe()
 {

              .arg(xmlEncode(output.left(800))
                   .replace("\n", "<br>"))
              : "");
 
     QMessageBox::warning(this, tr("Command failed"), message);
-
-/* todo:
-if ((runningAction == ACT_MERGE) && (exitCode != 0))
-            {
-                // If we had a failed merge, offer to retry
-                if (QMessageBox::Ok == QMessageBox::information(this, tr("Retry merge ?"), tr("Merge attempt failed. retry ?"), QMessageBox::Ok | QMessageBox::Cancel))
-                {
-                    runningAction = ACT_NONE;
-                    hgRetryMerge();
-                }
-                else
-                {
-                    runningAction = ACT_NONE;
-                    hgStat();
-                }
-            }
-            else
-            {
-*/
 }
 
 void MainWindow::commandCompleted(HgAction completedAction, QString output)
 {
     HGACTIONS action = completedAction.action;
 
     if (action == ACT_NONE) return;
 
-    bool shouldHgStat = false;
     bool headsChanged = false;
     QStringList oldHeadIds;
 
     switch (action) {
 

         currentBranch = output.trimmed();
         break;
 
     case ACT_STAT:
         if (fsWatcher) fsWatcher->blockSignals(false);
-        hgTabs->updateWorkFolderFileList(output);
+        lastStatOutput = output;
         updateFileSystemWatcher();
+        break;
+
+    case ACT_RESOLVE_LIST:
+        if (output != "") {
+            // Remove lines beginning with R (they are resolved,
+            // and the file stat parser treats R as removed)
+            QStringList outList = output.split('\n');
+            QStringList winnowed;
+            foreach (QString line, outList) {
+                if (!line.startsWith("R ")) winnowed.push_back(line);
+            }
+            output = winnowed.join("\n");
+        }
+        DEBUG << "lastStatOutput = " << lastStatOutput << endl;
+        DEBUG << "output = " << output << endl;
+        hgTabs->updateWorkFolderFileList(lastStatOutput + output);
+        break;
+
+    case ACT_RESOLVE_MARK:
+        shouldHgStat = true;
         break;
         
     case ACT_INCOMING:
         showIncoming(output);
         break;
 
     case ACT_ANNOTATE:
-    case ACT_RESOLVE_LIST:
-    case ACT_RESOLVE_MARK:
         presentLongStdoutToUser(output);
         shouldHgStat = true;
         break;
         
     case ACT_PULL:

     }
         break;
 
     case ACT_COMMIT:
         hgTabs->clearSelections();
+        justMerged = false;
         shouldHgStat = true;
+        break;
+
+    case ACT_REVERT:
+        hgMarkResolved(lastRevertedFiles);
+        justMerged = false;
         break;
         
     case ACT_REMOVE:
     case ACT_ADD:
-    case ACT_REVERT:
         hgTabs->clearSelections();
         shouldHgStat = true;
         break;
 
     case ACT_FOLDERDIFF:

         shouldHgStat = true;
         justMerged = true;
         break;
         
     case ACT_RETRY_MERGE:
-        QMessageBox::information(this, tr("Merge retry"),
-                                 tr("Merge retry successful."));
+        QMessageBox::information(this, tr("Resolved"),
+                                 tr("<qt><h3>Merge resolved</h3><p>Merge resolved successfully.</p>"));
         shouldHgStat = true;
         justMerged = true;
         break;
         
     default:
         break;
     }
 
     // Sequence when no full log required:
-    //   paths -> branch -> stat -> heads ->
+    //   paths -> branch -> stat -> resolve-list -> heads ->
     //     incremental-log (only if heads changed) -> parents
     // 
     // Sequence when full log required:
-    //   paths -> branch -> stat -> heads -> parents -> log
+    //   paths -> branch -> stat -> resolve-list -> heads -> parents -> log
     //
     // Note we want to call enableDisableActions only once, at the end
     // of whichever sequence is in use.
 
     bool noMore = false;

     case ACT_QUERY_BRANCH:
         hgStat();
         break;
         
     case ACT_STAT:
+        hgResolveList();
+        break;
+
+    case ACT_RESOLVE_LIST:
         hgQueryHeads();
         break;
 
     case ACT_QUERY_HEADS:
         if (headsChanged && !needNewLog) {

         // we're done
         noMore = true;
 
     default:
         if (shouldHgStat) {
+            shouldHgStat = false;
             hgQueryPaths();
         } else {
             noMore = true;
         }
         break;

     connect(hgFolderDiffAct, SIGNAL(triggered()), this, SLOT(hgFolderDiff()));
 //    connect(hgChgSetDiffAct, SIGNAL(triggered()), this, SLOT(hgChgSetDiff()));
     connect(hgUpdateAct, SIGNAL(triggered()), this, SLOT(hgUpdate()));
     connect(hgRevertAct, SIGNAL(triggered()), this, SLOT(hgRevert()));
     connect(hgMergeAct, SIGNAL(triggered()), this, SLOT(hgMerge()));
-    connect(hgRetryMergeAct, SIGNAL(triggered()), this, SLOT(hgRetryMerge()));
     connect(hgTagAct, SIGNAL(triggered()), this, SLOT(hgTag()));
     connect(hgIgnoreAct, SIGNAL(triggered()), this, SLOT(hgIgnore()));
 
     connect(settingsAct, SIGNAL(triggered()), this, SLOT(settings()));
     connect(openAct, SIGNAL(triggered()), this, SLOT(open()));

 
 //    connect(hgTabs, SIGNAL(currentChanged(int)), this, SLOT(tabChanged(int)));
 
 //    connect(hgUpdateToRevAct, SIGNAL(triggered()), this, SLOT(hgUpdateToRev()));
     connect(hgAnnotateAct, SIGNAL(triggered()), this, SLOT(hgAnnotate()));
-    connect(hgResolveListAct, SIGNAL(triggered()), this, SLOT(hgResolveList()));
-    connect(hgResolveMarkAct, SIGNAL(triggered()), this, SLOT(hgResolveMark()));
     connect(hgServeAct, SIGNAL(triggered()), this, SLOT(hgServe()));
     connect(clearSelectionsAct, SIGNAL(triggered()), this, SLOT(clearSelections()));
 }
 
 void MainWindow::connectTabsSignals()

     hgAddAct -> setEnabled(localRepoActionsEnabled);
     hgRemoveAct -> setEnabled(localRepoActionsEnabled);
     hgUpdateAct -> setEnabled(localRepoActionsEnabled);
     hgCommitAct -> setEnabled(localRepoActionsEnabled);
     hgMergeAct -> setEnabled(localRepoActionsEnabled);
-    hgRetryMergeAct -> setEnabled(localRepoActionsEnabled);
-    hgResolveListAct -> setEnabled(localRepoActionsEnabled);
-    hgResolveMarkAct -> setEnabled(localRepoActionsEnabled);
     hgAnnotateAct -> setEnabled(localRepoActionsEnabled);
     hgServeAct -> setEnabled(localRepoActionsEnabled);
     hgTagAct -> setEnabled(localRepoActionsEnabled);
     hgIgnoreAct -> setEnabled(localRepoActionsEnabled);
 

 
     //!!! new stuff:
     hgAddAct->setEnabled(localRepoActionsEnabled && hgTabs->canAdd());
     hgRemoveAct->setEnabled(localRepoActionsEnabled && hgTabs->canRemove());
     hgCommitAct->setEnabled(localRepoActionsEnabled && hgTabs->canCommit());
-    hgRevertAct->setEnabled(localRepoActionsEnabled && hgTabs->canCommit());
-    hgFolderDiffAct->setEnabled(localRepoActionsEnabled && hgTabs->canDoDiff());
+    hgRevertAct->setEnabled(localRepoActionsEnabled && hgTabs->canRevert());
+    hgFolderDiffAct->setEnabled(localRepoActionsEnabled && hgTabs->canDiff());
 
     // A default merge makes sense if:
     //  * there is only one parent (if there are two, we have an uncommitted merge) and
     //  * there are exactly two heads that have the same branch as the current branch and
     //  * our parent is one of those heads

         }
     } else if (currentParents.size() == 0) {
         emptyRepo = true;
     } else {
         haveMerge = true;
-    }
-        
-    hgMergeAct->setEnabled(localRepoActionsEnabled && canMerge);
-    hgUpdateAct->setEnabled(localRepoActionsEnabled && canUpdate);
+        justMerged = true;
+    }
+        
+    hgMergeAct->setEnabled(localRepoActionsEnabled &&
+                           (canMerge || hgTabs->canResolve()));
+    hgUpdateAct->setEnabled(localRepoActionsEnabled &&
+                            (canUpdate && !hgTabs->canRevert()));
 
     // Set the state field on the file status widget
 
     QString branchText;
     if (currentBranch == "" || currentBranch == "default") {

 
     if (emptyRepo) {
         hgTabs->setState(tr("Nothing committed to this repository yet"));
     } else if (canMerge) {
         hgTabs->setState(tr("<b>Awaiting merge</b> on %1").arg(branchText));
+    } else if (!hgTabs->getAllUnresolvedFiles().empty()) {
+        hgTabs->setState(tr("Have unresolved files following merge on %1").arg(branchText));
     } else if (haveMerge) {
         hgTabs->setState(tr("Have merged but not yet committed on %1").arg(branchText));
     } else if (canUpdate) {
-        hgTabs->setState(tr("On %1. Not at the head of the branch: consider updating").arg(branchText));
+        if (hgTabs->canRevert()) {
+            // have uncommitted changes
+            hgTabs->setState(tr("On %1. Not at the head of the branch").arg(branchText));
+        } else {
+            // no uncommitted changes
+            hgTabs->setState(tr("On %1. Not at the head of the branch: consider updating").arg(branchText));
+        }
     } else if (currentBranchHeads > 1) {
         hgTabs->setState(tr("At one of %n heads of %1", "", currentBranchHeads).arg(branchText));
     } else {
         hgTabs->setState(tr("At the head of %1").arg(branchText));
     }

 /*    hgUpdateToRevAct = new QAction(tr("Update to revision"), this);
     hgUpdateToRevAct -> setStatusTip(tr("Update working folder to version selected from history list"));
 */
     hgAnnotateAct = new QAction(tr("Annotate"), this);
     hgAnnotateAct -> setStatusTip(tr("Show line-by-line version information for selected file"));
-
-    hgResolveListAct = new QAction(tr("Resolve (list)"), this);
-    hgResolveListAct -> setStatusTip(tr("Resolve (list): Show list of files needing merge"));
-
-    hgResolveMarkAct = new QAction(tr("Resolve (mark)"), this);
-    hgResolveMarkAct -> setStatusTip(tr("Resolve (mark): Mark selected file status as resolved"));
-
-    hgRetryMergeAct = new QAction(tr("Retry merge"), this);
-    hgRetryMergeAct -> setStatusTip(tr("Retry merge after failed merge attempt."));
 
     hgTagAct = new QAction(tr("Tag revision"), this);
     hgTagAct -> setStatusTip(tr("Give decsriptive name (tag) to current workfolder parent revision."));
 
     hgIgnoreAct = new QAction(tr("Edit .hgignore"), this);