comparison mainwindow.cpp @ 90:b43355c2473a

* Add filesystem watcher; initial work on enable/disable logic for actions in new scheme

 #include <QMenuBar>
 #include <QApplication>
 #include <QToolBar>
 #include <QToolButton>
 #include <QSettings>
+#include <QInputDialog>
 
 #include "mainwindow.h"
 #include "settingsdialog.h"
 #include "multichoicedialog.h"
 #include "startupdialog.h"

 
 MainWindow::MainWindow()
 {
     QString wndTitle;
 
+    fsWatcher = 0;
+
     createActions();
     createMenus();
     createToolBars();
     createStatusBar();
 

 
 
 void MainWindow::closeEvent(QCloseEvent *)
 {
     writeSettings();
+    delete fsWatcher;
 }
 
 
 QString MainWindow::getUserInfo() const
 {

     }
 }
 
 void MainWindow::hgLog()
 {
+//!!! This needs to be incremental, except when we pull or set new repo
     if (runningAction == ACT_NONE)
     {
         QStringList params;
         params << "log";
         params << "--template";

         runner -> startHgCommand(workFolderPath, params);
         runningAction = ACT_ADD;
     }
 }
 
-int MainWindow::getCommentOrTag(QString& commentOrTag, QString question, QString dlgTitle)
-{
+bool MainWindow::getCommentOrTag(QString& commentOrTag,
+                                 QString question,
+                                 QString dlgTitle)
+{
+    bool ok = false;
+    QString text = QInputDialog::getText(this, dlgTitle, question, QLineEdit::Normal, commentOrTag, &ok);
+    commentOrTag = text;
+    return ok;
+
+            /*!!!
     int ret;
 
     QDialog dlg(this);
 
     QLabel *commentLabel = new QLabel(question);

     connect(btnCancel, SIGNAL(clicked()), &dlg, SLOT(reject()));
 
     ret = dlg.exec();
     commentOrTag = commentOrTagEdit -> text();
     return ret;
+    */
 }
 
 void MainWindow::hgCommit()
 {
     if (runningAction == ACT_NONE)
     {
         QStringList params;
         QString comment;
         
-        if (QDialog::Accepted == getCommentOrTag(comment, tr("Comment:"), tr("Save (commit)")))
+        if (getCommentOrTag(comment, tr("Comment:"), tr("Save (commit)")))
         {
             if (!comment.isEmpty())
             {
                 if ((justMerged == false) && (areAllSelectedCommitable(hgExp -> workFolderFileList)))
                 {

     if (runningAction == ACT_NONE)
     {
         QStringList params;
         QString tag;
 
-        if (QDialog::Accepted == getCommentOrTag(tag, tr("Tag:"), tr("Tag")))
+        if (getCommentOrTag(tag, tr("Tag:"), tr("Tag")))
         {
             if (!tag.isEmpty())
             {
                 params << "tag" << "--user" << getUserInfo() << filterTag(tag);
 

         selectedRemoved = 0;
         selectedNotTracked = 0;
     }
 }
 
+
+void MainWindow::updateFileSystemWatcher()
+{
+    //!!! this needs to be incremental when something changes
+
+    delete fsWatcher;
+    fsWatcher = new QFileSystemWatcher();
+    std::deque<QString> pending;
+    pending.push_back(workFolderPath);
+    while (!pending.empty()) {
+        QString path = pending.front();
+        pending.pop_front();
+        fsWatcher->addPath(path);
+        DEBUG << "Added to file system watcher: " << path << endl;
+        QDir d(path);
+        if (d.exists()) {
+            d.setFilter(QDir::Files | QDir::Dirs |
+                        QDir::NoDotAndDotDot | QDir::Readable);
+            foreach (QString entry, d.entryList()) {
+                if (entry == ".hg") continue;
+                QString entryPath = d.absoluteFilePath(entry);
+                pending.push_back(entryPath);
+            }
+        }
+    }
+    connect(fsWatcher, SIGNAL(directoryChanged(QString)),
+            this, SLOT(fsDirectoryChanged(QString)));
+    connect(fsWatcher, SIGNAL(fileChanged(QString)),
+            this, SLOT(fsFileChanged(QString)));
+}
+
+void MainWindow::fsDirectoryChanged(QString)
+{
+    //!!! should just queue one of these!
+    hgStat();
+}
+
+void MainWindow::fsFileChanged(QString)
+{
+    //!!! should just queue one of these!
+    hgStat();
+}
 
 void MainWindow::commandFailed()
 {
     DEBUG << "MainWindow::commandFailed" << endl;
     runningAction = ACT_NONE;

                         break;
                     }
 
                     case ACT_STAT:
                         hgExp -> updateWorkFolderFileList(runner -> getOutput());
+                        updateFileSystemWatcher();
                         break;
 
                     case ACT_INCOMING:
                     case ACT_ANNOTATE:
                     case ACT_RESOLVE_LIST:

                     hgPaths();
                 }
             }
         }
     }
-    else
-    {
-        enableDisableActions();
-    }
+
+    enableDisableActions();
 }
 
 void MainWindow::connectActions()
 {
     connect(exitAct, SIGNAL(triggered()), this, SLOT(close()));

 
 }
 
 void MainWindow::enableDisableActions()
 {
+    DEBUG << "MainWindow::enableDisableActions" << endl;
+
     QDir localRepoDir;
     QDir workFolderDir;
     bool workFolderExist;
     bool localRepoExist;
 
     remoteRepoActionsEnabled = true;
-    if (remoteRepoPath.isEmpty())
-    {
+    if (remoteRepoPath.isEmpty()) {
         remoteRepoActionsEnabled = false;
     }
 
     localRepoActionsEnabled = true;
-    if (workFolderPath.isEmpty())
-    {
+    if (workFolderPath.isEmpty()) {
         localRepoActionsEnabled = false;
         workFolderExist = false;
     }
 
-    if (!workFolderDir.exists(workFolderPath))
-    {
+    if (!workFolderDir.exists(workFolderPath)) {
         localRepoActionsEnabled = false;
         workFolderExist = false;
-    }
-    else
-    {
+    } else {
         workFolderExist = true;
     }
 
-    if (!localRepoDir.exists(workFolderPath + getHgDirName()))
-    {
+    if (!localRepoDir.exists(workFolderPath + "/" + getHgDirName())) {
         localRepoActionsEnabled = false;
         localRepoExist = false;
     }
 
     hgCloneFromRemoteAct -> setEnabled(remoteRepoActionsEnabled);

     hgTagAct -> setEnabled(localRepoActionsEnabled);
     hgIgnoreAct -> setEnabled(localRepoActionsEnabled);
 
     hgExp -> enableDisableOtherTabs(tabPage);
 
+    DEBUG << "localRepoActionsEnabled = " << localRepoActionsEnabled << endl;
+    DEBUG << "canCommit = " << hgExp->canCommit() << endl;
+
+    //!!! new stuff:
+    hgCommitAct->setEnabled(localRepoActionsEnabled && hgExp->canCommit());
+    hgRevertAct->setEnabled(localRepoActionsEnabled && hgExp->canCommit());
+
+/*!!!
     int added, modified, removed, notTracked, selected, selectedAdded, selectedModified, selectedRemoved, selectedNotTracked;
 
     countModifications(hgExp -> workFolderFileList,
         added, modified, removed, notTracked,
         selected,

         else
         {
             hgUpdateToRevAct -> setEnabled(false);
         }
     }
+    */
 }
 
 void MainWindow::createActions()
 {
     //File actions