src/TortoiseProc/CommitDlg.cpp

   1 // TortoiseGit - a Windows shell extension for easy version control
   2
   3 // Copyright (C) 2003-2013 - TortoiseSVN
   4 // Copyright (C) 2008-2013 - TortoiseGit
   5
   6 // This program is free software; you can redistribute it and/or
   7 // modify it under the terms of the GNU General Public License
   8 // as published by the Free Software Foundation; either version 2
   9 // of the License, or (at your option) any later version.
  10
  11 // This program is distributed in the hope that it will be useful,
  12 // but WITHOUT ANY WARRANTY; without even the implied warranty of
  13 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14 // GNU General Public License for more details.
  15
  16 // You should have received a copy of the GNU General Public License
  17 // along with this program; if not, write to the Free Software Foundation,
  18 // 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
  19 //
  20 #include "stdafx.h"
  21 #include "TortoiseProc.h"
  22 #include "CommitDlg.h"
  23 #include "DirFileEnum.h"
  24 #include "MessageBox.h"
  25 #include "AppUtils.h"
  26 #include "PathUtils.h"
  27 #include "Git.h"
  28 #include "registry.h"
  29 #include "GitStatus.h"
  30 #include "HistoryDlg.h"
  31 #include "Hooks.h"
  32 #include "UnicodeUtils.h"
  33 #include "../TGitCache/CacheInterface.h"
  34 #include "ProgressDlg.h"
  35 #include "ShellUpdater.h"
  36 #include "Commands/PushCommand.h"
  37 #include "PatchViewDlg.h"
  38 #include "COMError.h"
  39 #include "Globals.h"
  40 #include "SysProgressDlg.h"
  41 #include "MassiveGitTask.h"
  42 #include "LogDlg.h"
  43
  44 #ifdef _DEBUG
  45 #define new DEBUG_NEW
  46 #undef THIS_FILE
  47 static char THIS_FILE[] = __FILE__;
  48 #endif
  49
  50 UINT CCommitDlg::WM_AUTOLISTREADY = RegisterWindowMessage(_T("TORTOISEGIT_AUTOLISTREADY_MSG"));
  51 UINT CCommitDlg::WM_UPDATEOKBUTTON = RegisterWindowMessage(_T("TORTOISEGIT_COMMIT_UPDATEOKBUTTON"));
  52 UINT CCommitDlg::WM_UPDATEDATAFALSE = RegisterWindowMessage(_T("TORTOISEGIT_COMMIT_UPDATEDATAFALSE"));
  53
  54 IMPLEMENT_DYNAMIC(CCommitDlg, CResizableStandAloneDialog)
  55 CCommitDlg::CCommitDlg(CWnd* pParent /*=NULL*/)
  56         : CResizableStandAloneDialog(CCommitDlg::IDD, pParent)
  57         , m_bRecursive(FALSE)
  58         , m_bShowUnversioned(FALSE)
  59         , m_bBlock(FALSE)
  60         , m_bThreadRunning(FALSE)
  61         , m_bRunThread(FALSE)
  62         , m_pThread(NULL)
  63         , m_bWholeProject(FALSE)
  64         , m_bKeepChangeList(TRUE)
  65         , m_bDoNotAutoselectSubmodules(FALSE)
  66         , m_itemsCount(0)
  67         , m_bSelectFilesForCommit(TRUE)
  68         , m_bNoPostActions(FALSE)
  69         , m_bAutoClose(false)
  70         , m_bSetCommitDateTime(FALSE)
  71         , m_bCreateNewBranch(FALSE)
  72         , m_bCreateTagAfterCommit(FALSE)
  73         , m_bPullAfterCommit(FALSE)
  74         , m_bForceCommitAmend(false)
  75         , m_bCommitMessageOnly(FALSE)
  76         , m_bSetAuthor(FALSE)
  77         , m_bCancelled(false)
  78         , m_PostCmd(-1)
  79         , m_bAmendDiffToLastCommit(FALSE)
  80         , m_nPopupPasteListCmd(0)
  81         , m_nPopupPasteLastMessage(0)
  82         , m_nPopupRecentMessage(0)
  83         , m_nPopupPickCommitHash(0)
  84         , m_hAccel(nullptr)
  85 {
  86         this->m_bCommitAmend=FALSE;
  87         m_bPushAfterCommit = FALSE;
  88 }
  89
  90 CCommitDlg::~CCommitDlg()
  91 {
  92         if(m_pThread != NULL)
  93         {
  94                 delete m_pThread;
  95         }
  96 }
  97
  98 void CCommitDlg::DoDataExchange(CDataExchange* pDX)
  99 {
 100         CResizableStandAloneDialog::DoDataExchange(pDX);
 101         DDX_Control(pDX, IDC_FILELIST, m_ListCtrl);
 102         DDX_Control(pDX, IDC_LOGMESSAGE, m_cLogMessage);
 103         DDX_Check(pDX, IDC_SHOWUNVERSIONED, m_bShowUnversioned);
 104         DDX_Check(pDX, IDC_COMMIT_SETDATETIME, m_bSetCommitDateTime);
 105         DDX_Check(pDX, IDC_CHECK_NEWBRANCH, m_bCreateNewBranch);
 106         DDX_Text(pDX, IDC_NEWBRANCH, m_sCreateNewBranch);
 107         DDX_Text(pDX, IDC_BUGID, m_sBugID);
 108         DDX_Text(pDX, IDC_COMMIT_AUTHORDATA, m_sAuthor);
 109         DDX_Check(pDX, IDC_WHOLE_PROJECT, m_bWholeProject);
 110         DDX_Control(pDX, IDC_SPLITTER, m_wndSplitter);
 111         DDX_Check(pDX, IDC_KEEPLISTS, m_bKeepChangeList);
 112         DDX_Check(pDX, IDC_NOAUTOSELECTSUBMODULES, m_bDoNotAutoselectSubmodules);
 113         DDX_Check(pDX,IDC_COMMIT_AMEND,m_bCommitAmend);
 114         DDX_Check(pDX, IDC_COMMIT_MESSAGEONLY, m_bCommitMessageOnly);
 115         DDX_Check(pDX,IDC_COMMIT_AMENDDIFF,m_bAmendDiffToLastCommit);
 116         DDX_Check(pDX, IDC_COMMIT_SETAUTHOR, m_bSetAuthor);
 117         DDX_Control(pDX,IDC_VIEW_PATCH,m_ctrlShowPatch);
 118         DDX_Control(pDX, IDC_COMMIT_DATEPICKER, m_CommitDate);
 119         DDX_Control(pDX, IDC_COMMIT_TIMEPICKER, m_CommitTime);
 120 }
 121
 122 BEGIN_MESSAGE_MAP(CCommitDlg, CResizableStandAloneDialog)
 123         ON_BN_CLICKED(IDC_SHOWUNVERSIONED, OnBnClickedShowunversioned)
 124         ON_NOTIFY(SCN_UPDATEUI, IDC_LOGMESSAGE, OnScnUpdateUI)
 125 //      ON_BN_CLICKED(IDC_HISTORY, OnBnClickedHistory)
 126         ON_BN_CLICKED(IDC_BUGTRAQBUTTON, OnBnClickedBugtraqbutton)
 127         ON_EN_CHANGE(IDC_LOGMESSAGE, OnEnChangeLogmessage)
 128         ON_REGISTERED_MESSAGE(CGitStatusListCtrl::GITSLNM_ITEMCOUNTCHANGED, OnGitStatusListCtrlItemCountChanged)
 129         ON_REGISTERED_MESSAGE(CGitStatusListCtrl::GITSLNM_NEEDSREFRESH, OnGitStatusListCtrlNeedsRefresh)
 130         ON_REGISTERED_MESSAGE(CGitStatusListCtrl::GITSLNM_ADDFILE, OnFileDropped)
 131         ON_REGISTERED_MESSAGE(CGitStatusListCtrl::GITSLNM_CHECKCHANGED, &CCommitDlg::OnGitStatusListCtrlCheckChanged)
 132         ON_REGISTERED_MESSAGE(CGitStatusListCtrl::GITSLNM_ITEMCHANGED, &CCommitDlg::OnGitStatusListCtrlItemChanged)
 133
 134         ON_REGISTERED_MESSAGE(CLinkControl::LK_LINKITEMCLICKED, &CCommitDlg::OnCheck)
 135         ON_REGISTERED_MESSAGE(WM_AUTOLISTREADY, OnAutoListReady)
 136         ON_REGISTERED_MESSAGE(WM_UPDATEOKBUTTON, OnUpdateOKButton)
 137         ON_REGISTERED_MESSAGE(WM_UPDATEDATAFALSE, OnUpdateDataFalse)
 138         ON_WM_TIMER()
 139         ON_WM_SIZE()
 140         ON_STN_CLICKED(IDC_EXTERNALWARNING, &CCommitDlg::OnStnClickedExternalwarning)
 141         ON_BN_CLICKED(IDC_SIGNOFF, &CCommitDlg::OnBnClickedSignOff)
 142         ON_BN_CLICKED(IDC_COMMIT_AMEND, &CCommitDlg::OnBnClickedCommitAmend)
 143         ON_BN_CLICKED(IDC_COMMIT_MESSAGEONLY, &CCommitDlg::OnBnClickedCommitMessageOnly)
 144         ON_BN_CLICKED(IDC_WHOLE_PROJECT, &CCommitDlg::OnBnClickedWholeProject)
 145         ON_COMMAND(ID_FOCUS_MESSAGE,&CCommitDlg::OnFocusMessage)
 146         ON_COMMAND(ID_FOCUS_FILELIST, OnFocusFileList)
 147         ON_STN_CLICKED(IDC_VIEW_PATCH, &CCommitDlg::OnStnClickedViewPatch)
 148         ON_WM_MOVE()
 149         ON_WM_MOVING()
 150         ON_WM_SIZING()
 151         ON_NOTIFY(HDN_ITEMCHANGED, 0, &CCommitDlg::OnHdnItemchangedFilelist)
 152         ON_BN_CLICKED(IDC_COMMIT_AMENDDIFF, &CCommitDlg::OnBnClickedCommitAmenddiff)
 153         ON_BN_CLICKED(IDC_NOAUTOSELECTSUBMODULES, &CCommitDlg::OnBnClickedNoautoselectsubmodules)
 154         ON_BN_CLICKED(IDC_COMMIT_SETDATETIME, &CCommitDlg::OnBnClickedCommitSetDateTime)
 155         ON_BN_CLICKED(IDC_CHECK_NEWBRANCH, &CCommitDlg::OnBnClickedCheckNewBranch)
 156         ON_BN_CLICKED(IDC_COMMIT_SETAUTHOR, &CCommitDlg::OnBnClickedCommitSetauthor)
 157 END_MESSAGE_MAP()
 158
 159 bool PrefillMessage(const CString &filename, CString &msg)
 160 {
 161         if (PathFileExists(filename))
 162         {
 163                 CStdioFile file;
 164                 if (file.Open(filename, CFile::modeRead | CFile::typeBinary))
 165                 {
 166                         CString str;
 167                         std::unique_ptr<BYTE[]> buf(new BYTE[file.GetLength()]);
 168                         UINT read = file.Read(buf.get(), (UINT)file.GetLength());
 169                         g_Git.StringAppend(&str, buf.get(), CP_UTF8, read);
 170                         str.Replace(_T("\r\n"), _T("\n"));
 171                         str.TrimRight(_T("\n"));
 172                         str += _T("\n");
 173                         msg = str;
 174                 }
 175                 else
 176                         ::MessageBox(nullptr, _T("Could not open ") + filename, _T("TortoiseGit"), MB_ICONERROR);
 177                 return true; // load no further files
 178         }
 179         return false;
 180 }
 181
 182 int GetCommitTemplate(CString &msg)
 183 {
 184         CString tplFilename = g_Git.GetConfigValue(_T("commit.template"));
 185         if (tplFilename.IsEmpty())
 186                 return -1;
 187
 188         if (tplFilename[0] == _T('/'))
 189         {
 190                 if (tplFilename.GetLength() >= 3)
 191                 {
 192                         // handle "/d/TortoiseGit/tpl.txt" -> "d:/TortoiseGit/tpl.txt"
 193                         if (tplFilename[2] == _T('/'))
 194                         {
 195                                 tplFilename.GetBuffer()[0] = tplFilename[1];
 196                                 tplFilename.GetBuffer()[1] = _T(':');
 197                         }
 198                 }
 199         }
 200
 201         tplFilename.Replace(_T('/'), _T('\\'));
 202
 203         if (!PrefillMessage(tplFilename, msg))
 204                 return -1;
 205         return 0;
 206 }
 207
 208 BOOL CCommitDlg::OnInitDialog()
 209 {
 210         CResizableStandAloneDialog::OnInitDialog();
 211         CAppUtils::MarkWindowAsUnpinnable(m_hWnd);
 212
 213         if (!m_bForceCommitAmend)
 214                 GetCommitTemplate(this->m_sLogMessage);
 215
 216         CString dotGitPath;
 217         g_GitAdminDir.GetAdminDirPath(g_Git.m_CurrentDir, dotGitPath);
 218         bool loadedMsg = !PrefillMessage(dotGitPath + _T("MERGE_MSG"), m_sLogMessage);
 219         loadedMsg = loadedMsg && !PrefillMessage(dotGitPath + _T("SQUASH_MSG"), m_sLogMessage);
 220
 221         if (CTGitPath(g_Git.m_CurrentDir).IsMergeActive())
 222         {
 223                 DialogEnableWindow(IDC_CHECK_NEWBRANCH, FALSE);
 224                 m_bCreateNewBranch = FALSE;
 225                 GetDlgItem(IDC_MERGEACTIVE)->ShowWindow(SW_SHOW);
 226         }
 227
 228         m_regAddBeforeCommit = CRegDWORD(_T("Software\\TortoiseGit\\AddBeforeCommit"), TRUE);
 229         m_bShowUnversioned = m_regAddBeforeCommit;
 230
 231         m_History.SetMaxHistoryItems((LONG)CRegDWORD(_T("Software\\TortoiseGit\\MaxHistoryItems"), 25));
 232
 233         m_regKeepChangelists = CRegDWORD(_T("Software\\TortoiseGit\\KeepChangeLists"), FALSE);
 234         m_bKeepChangeList = m_regKeepChangelists;
 235
 236         m_regDoNotAutoselectSubmodules = CRegDWORD(_T("Software\\TortoiseGit\\DoNotAutoselectSubmodules"), FALSE);
 237         m_bDoNotAutoselectSubmodules = m_regDoNotAutoselectSubmodules;
 238
 239         m_hAccel = LoadAccelerators(AfxGetResourceHandle(),MAKEINTRESOURCE(IDR_ACC_COMMITDLG));
 240
 241 //      GitConfig config;
 242 //      m_bWholeProject = config.KeepLocks();
 243
 244         if(this->m_pathList.GetCount() == 0)
 245                 m_bWholeProject =true;
 246
 247         if(this->m_pathList.GetCount() == 1 && m_pathList[0].IsEmpty())
 248                 m_bWholeProject =true;
 249
 250         SetDlgTitle();
 251
 252         UpdateData(FALSE);
 253
 254         m_ListCtrl.Init(GITSLC_COLEXT | GITSLC_COLSTATUS | GITSLC_COLADD | GITSLC_COLDEL, _T("CommitDlg"),(GITSLC_POPALL ^ (GITSLC_POPCOMMIT | GITSLC_POPSAVEAS)), true, true);
 255         m_ListCtrl.SetStatLabel(GetDlgItem(IDC_STATISTICS));
 256         m_ListCtrl.SetCancelBool(&m_bCancelled);
 257         m_ListCtrl.SetEmptyString(IDS_COMMITDLG_NOTHINGTOCOMMIT);
 258         m_ListCtrl.EnableFileDrop();
 259         m_ListCtrl.SetBackgroundImage(IDI_COMMIT_BKG);
 260
 261         //this->DialogEnableWindow(IDC_COMMIT_AMEND,FALSE);
 262         m_ProjectProperties.ReadProps();
 263
 264         m_cLogMessage.Init(m_ProjectProperties);
 265         m_cLogMessage.SetFont((CString)CRegString(_T("Software\\TortoiseGit\\LogFontName"), _T("Courier New")), (DWORD)CRegDWORD(_T("Software\\TortoiseGit\\LogFontSize"), 8));
 266         m_cLogMessage.RegisterContextMenuHandler(this);
 267
 268         OnEnChangeLogmessage();
 269
 270         m_tooltips.Create(this);
 271         m_tooltips.AddTool(IDC_EXTERNALWARNING, IDS_COMMITDLG_EXTERNALS);
 272         m_tooltips.AddTool(IDC_COMMIT_AMEND,IDS_COMMIT_AMEND_TT);
 273         m_tooltips.AddTool(IDC_MERGEACTIVE, IDC_MERGEACTIVE_TT);
 274 //      m_tooltips.AddTool(IDC_HISTORY, IDS_COMMITDLG_HISTORY_TT);
 275
 276         CBugTraqAssociations bugtraq_associations;
 277         bugtraq_associations.Load(m_ProjectProperties.GetProviderUUID(), m_ProjectProperties.sProviderParams);
 278
 279         if (bugtraq_associations.FindProvider(g_Git.m_CurrentDir, &m_bugtraq_association))
 280         {
 281                 GetDlgItem(IDC_BUGID)->ShowWindow(SW_HIDE);
 282                 GetDlgItem(IDC_BUGIDLABEL)->ShowWindow(SW_HIDE);
 283
 284                 CComPtr<IBugTraqProvider> pProvider;
 285                 HRESULT hr = pProvider.CoCreateInstance(m_bugtraq_association.GetProviderClass());
 286                 if (SUCCEEDED(hr))
 287                 {
 288                         m_BugTraqProvider = pProvider;
 289                         BSTR temp = NULL;
 290                         if (SUCCEEDED(hr = pProvider->GetLinkText(GetSafeHwnd(), m_bugtraq_association.GetParameters().AllocSysString(), &temp)))
 291                         {
 292                                 SetDlgItemText(IDC_BUGTRAQBUTTON, temp);
 293                                 GetDlgItem(IDC_BUGTRAQBUTTON)->EnableWindow(TRUE);
 294                                 GetDlgItem(IDC_BUGTRAQBUTTON)->ShowWindow(SW_SHOW);
 295                         }
 296
 297                         SysFreeString(temp);
 298                 }
 299
 300                 GetDlgItem(IDC_LOGMESSAGE)->SetFocus();
 301         }
 302         else if (!m_ProjectProperties.sMessage.IsEmpty())
 303         {
 304                 GetDlgItem(IDC_BUGID)->ShowWindow(SW_SHOW);
 305                 GetDlgItem(IDC_BUGIDLABEL)->ShowWindow(SW_SHOW);
 306                 if (!m_ProjectProperties.sLabel.IsEmpty())
 307                         SetDlgItemText(IDC_BUGIDLABEL, m_ProjectProperties.sLabel);
 308                 GetDlgItem(IDC_BUGTRAQBUTTON)->ShowWindow(SW_HIDE);
 309                 GetDlgItem(IDC_BUGTRAQBUTTON)->EnableWindow(FALSE);
 310                 GetDlgItem(IDC_BUGID)->SetFocus();
 311                 CString sBugID = m_ProjectProperties.GetBugIDFromLog(m_sLogMessage);
 312                 if (!sBugID.IsEmpty())
 313                 {
 314                         SetDlgItemText(IDC_BUGID, sBugID);
 315                 }
 316         }
 317         else
 318         {
 319                 GetDlgItem(IDC_BUGID)->ShowWindow(SW_HIDE);
 320                 GetDlgItem(IDC_BUGIDLABEL)->ShowWindow(SW_HIDE);
 321                 GetDlgItem(IDC_BUGTRAQBUTTON)->ShowWindow(SW_HIDE);
 322                 GetDlgItem(IDC_BUGTRAQBUTTON)->EnableWindow(FALSE);
 323                 GetDlgItem(IDC_LOGMESSAGE)->SetFocus();
 324         }
 325
 326         if (!m_sLogMessage.IsEmpty())
 327         {
 328                 m_cLogMessage.SetText(m_sLogMessage);
 329                 m_cLogMessage.Call(SCI_SETCURRENTPOS, 0);
 330                 m_cLogMessage.Call(SCI_SETSEL, 0, 0);
 331         }
 332
 333         GetWindowText(m_sWindowTitle);
 334
 335         AdjustControlSize(IDC_SHOWUNVERSIONED);
 336         AdjustControlSize(IDC_WHOLE_PROJECT);
 337         AdjustControlSize(IDC_CHECK_NEWBRANCH);
 338         AdjustControlSize(IDC_COMMIT_AMEND);
 339         AdjustControlSize(IDC_COMMIT_MESSAGEONLY);
 340         AdjustControlSize(IDC_COMMIT_AMENDDIFF);
 341         AdjustControlSize(IDC_COMMIT_SETDATETIME);
 342         AdjustControlSize(IDC_COMMIT_SETAUTHOR);
 343         AdjustControlSize(IDC_NOAUTOSELECTSUBMODULES);
 344         AdjustControlSize(IDC_KEEPLISTS);
 345
 346         m_linkControl.ConvertStaticToLink(m_hWnd, IDC_CHECKALL);
 347         m_linkControl.ConvertStaticToLink(m_hWnd, IDC_CHECKNONE);
 348         m_linkControl.ConvertStaticToLink(m_hWnd, IDC_CHECKUNVERSIONED);
 349         m_linkControl.ConvertStaticToLink(m_hWnd, IDC_CHECKVERSIONED);
 350         m_linkControl.ConvertStaticToLink(m_hWnd, IDC_CHECKADDED);
 351         m_linkControl.ConvertStaticToLink(m_hWnd, IDC_CHECKDELETED);
 352         m_linkControl.ConvertStaticToLink(m_hWnd, IDC_CHECKMODIFIED);
 353         m_linkControl.ConvertStaticToLink(m_hWnd, IDC_CHECKFILES);
 354         m_linkControl.ConvertStaticToLink(m_hWnd, IDC_CHECKSUBMODULES);
 355
 356         // line up all controls and adjust their sizes.
 357 #define LINKSPACING 9
 358         RECT rc = AdjustControlSize(IDC_SELECTLABEL);
 359         rc.right -= 15; // AdjustControlSize() adds 20 pixels for the checkbox/radio button bitmap, but this is a label...
 360         rc = AdjustStaticSize(IDC_CHECKALL, rc, LINKSPACING);
 361         rc = AdjustStaticSize(IDC_CHECKNONE, rc, LINKSPACING);
 362         rc = AdjustStaticSize(IDC_CHECKUNVERSIONED, rc, LINKSPACING);
 363         rc = AdjustStaticSize(IDC_CHECKVERSIONED, rc, LINKSPACING);
 364         rc = AdjustStaticSize(IDC_CHECKADDED, rc, LINKSPACING);
 365         rc = AdjustStaticSize(IDC_CHECKDELETED, rc, LINKSPACING);
 366         rc = AdjustStaticSize(IDC_CHECKMODIFIED, rc, LINKSPACING);
 367         rc = AdjustStaticSize(IDC_CHECKFILES, rc, LINKSPACING);
 368         rc = AdjustStaticSize(IDC_CHECKSUBMODULES, rc, LINKSPACING);
 369
 370         GetClientRect(m_DlgOrigRect);
 371         m_cLogMessage.GetClientRect(m_LogMsgOrigRect);
 372
 373         AddAnchor(IDC_COMMITLABEL, TOP_LEFT, TOP_RIGHT);
 374         AddAnchor(IDC_BUGIDLABEL, TOP_RIGHT);
 375         AddAnchor(IDC_BUGID, TOP_RIGHT);
 376         AddAnchor(IDC_BUGTRAQBUTTON, TOP_RIGHT);
 377         AddAnchor(IDC_COMMIT_TO, TOP_LEFT, TOP_RIGHT);
 378         AddAnchor(IDC_CHECK_NEWBRANCH, TOP_RIGHT);
 379         AddAnchor(IDC_NEWBRANCH, TOP_LEFT, TOP_RIGHT);
 380         AddAnchor(IDC_MESSAGEGROUP, TOP_LEFT, TOP_RIGHT);
 381 //      AddAnchor(IDC_HISTORY, TOP_LEFT);
 382         AddAnchor(IDC_LOGMESSAGE, TOP_LEFT, TOP_RIGHT);
 383         AddAnchor(IDC_SIGNOFF, TOP_RIGHT);
 384         AddAnchor(IDC_VIEW_PATCH, BOTTOM_RIGHT);
 385         AddAnchor(IDC_LISTGROUP, TOP_LEFT, BOTTOM_RIGHT);
 386         AddAnchor(IDC_SPLITTER, TOP_LEFT, TOP_RIGHT);
 387         AddAnchor(IDC_FILELIST, TOP_LEFT, BOTTOM_RIGHT);
 388         AddAnchor(IDC_SHOWUNVERSIONED, BOTTOM_LEFT);
 389         AddAnchor(IDC_EXTERNALWARNING, BOTTOM_RIGHT);
 390         AddAnchor(IDC_STATISTICS, BOTTOM_LEFT, BOTTOM_RIGHT);
 391         AddAnchor(IDC_TEXT_INFO, TOP_RIGHT);
 392         AddAnchor(IDC_WHOLE_PROJECT, BOTTOM_LEFT);
 393         AddAnchor(IDC_KEEPLISTS, BOTTOM_LEFT);
 394         AddAnchor(IDC_NOAUTOSELECTSUBMODULES, BOTTOM_LEFT);
 395         AddAnchor(IDOK, BOTTOM_RIGHT);
 396         AddAnchor(IDCANCEL, BOTTOM_RIGHT);
 397         AddAnchor(IDHELP, BOTTOM_RIGHT);
 398         AddAnchor(IDC_MERGEACTIVE, BOTTOM_RIGHT);
 399         AddAnchor(IDC_COMMIT_AMEND,TOP_LEFT);
 400         AddAnchor(IDC_COMMIT_MESSAGEONLY, BOTTOM_LEFT);
 401         AddAnchor(IDC_COMMIT_AMENDDIFF,TOP_LEFT);
 402         AddAnchor(IDC_COMMIT_SETDATETIME,TOP_LEFT);
 403         AddAnchor(IDC_COMMIT_DATEPICKER,TOP_LEFT);
 404         AddAnchor(IDC_COMMIT_TIMEPICKER,TOP_LEFT);
 405         AddAnchor(IDC_COMMIT_SETAUTHOR, TOP_LEFT);
 406         AddAnchor(IDC_COMMIT_AUTHORDATA, TOP_LEFT, TOP_RIGHT);
 407
 408         AddAnchor(IDC_SELECTLABEL, TOP_LEFT);
 409         AddAnchor(IDC_CHECKALL, TOP_LEFT);
 410         AddAnchor(IDC_CHECKNONE, TOP_LEFT);
 411         AddAnchor(IDC_CHECKUNVERSIONED, TOP_LEFT);
 412         AddAnchor(IDC_CHECKVERSIONED, TOP_LEFT);
 413         AddAnchor(IDC_CHECKADDED, TOP_LEFT);
 414         AddAnchor(IDC_CHECKDELETED, TOP_LEFT);
 415         AddAnchor(IDC_CHECKMODIFIED, TOP_LEFT);
 416         AddAnchor(IDC_CHECKFILES, TOP_LEFT);
 417         AddAnchor(IDC_CHECKSUBMODULES, TOP_LEFT);
 418
 419         if (hWndExplorer)
 420                 CenterWindow(CWnd::FromHandle(hWndExplorer));
 421         EnableSaveRestore(_T("CommitDlg"));
 422         DWORD yPos = CRegDWORD(_T("Software\\TortoiseGit\\TortoiseProc\\ResizableState\\CommitDlgSizer"));
 423         RECT rcDlg, rcLogMsg, rcFileList;
 424         GetClientRect(&rcDlg);
 425         m_cLogMessage.GetWindowRect(&rcLogMsg);
 426         ScreenToClient(&rcLogMsg);
 427         m_ListCtrl.GetWindowRect(&rcFileList);
 428         ScreenToClient(&rcFileList);
 429         if (yPos)
 430         {
 431                 RECT rectSplitter;
 432                 m_wndSplitter.GetWindowRect(&rectSplitter);
 433                 ScreenToClient(&rectSplitter);
 434                 int delta = yPos - rectSplitter.top;
 435                 if ((rcLogMsg.bottom + delta > rcLogMsg.top)&&(rcLogMsg.bottom + delta < rcFileList.bottom - 30))
 436                 {
 437                         m_wndSplitter.SetWindowPos(NULL, rectSplitter.left, yPos, 0, 0, SWP_NOSIZE);
 438                         DoSize(delta);
 439                 }
 440         }
 441
 442         SetSplitterRange();
 443
 444         // add all directories to the watcher
 445         /*
 446         for (int i=0; i<m_pathList.GetCount(); ++i)
 447         {
 448                 if (m_pathList[i].IsDirectory())
 449                         m_pathwatcher.AddPath(m_pathList[i]);
 450         }*/
 451
 452         m_updatedPathList = m_pathList;
 453
 454         //first start a thread to obtain the file list with the status without
 455         //blocking the dialog
 456         InterlockedExchange(&m_bBlock, TRUE);
 457         m_pThread = AfxBeginThread(StatusThreadEntry, this, THREAD_PRIORITY_NORMAL,0,CREATE_SUSPENDED);
 458         if (m_pThread==NULL)
 459         {
 460                 CMessageBox::Show(this->m_hWnd, IDS_ERR_THREADSTARTFAILED, IDS_APPNAME, MB_OK | MB_ICONERROR);
 461                 InterlockedExchange(&m_bBlock, FALSE);
 462         }
 463         else
 464         {
 465                 m_pThread->m_bAutoDelete = FALSE;
 466                 m_pThread->ResumeThread();
 467         }
 468         CRegDWORD err = CRegDWORD(_T("Software\\TortoiseGit\\ErrorOccurred"), FALSE);
 469         CRegDWORD historyhint = CRegDWORD(_T("Software\\TortoiseGit\\HistoryHintShown"), FALSE);
 470         if ((((DWORD)err)!=FALSE)&&((((DWORD)historyhint)==FALSE)))
 471         {
 472                 historyhint = TRUE;
 473 //              ShowBalloon(IDC_HISTORY, IDS_COMMITDLG_HISTORYHINT_TT, IDI_INFORMATION);
 474         }
 475         err = FALSE;
 476
 477         this->m_ctrlShowPatch.SetURL(CString());
 478
 479         if (g_Git.GetConfigValueBool(_T("tgit.commitshowpatch")))
 480                 OnStnClickedViewPatch();
 481
 482         return FALSE;  // return TRUE unless you set the focus to a control
 483         // EXCEPTION: OCX Property Pages should return FALSE
 484 }
 485
 486 static bool UpdateIndex(CMassiveGitTask &mgt, CSysProgressDlg &sysProgressDlg, int progress, int maxProgress)
 487 {
 488         if (sysProgressDlg.HasUserCancelled())
 489                 return false;
 490
 491         if (sysProgressDlg.IsVisible())
 492         {
 493                 sysProgressDlg.SetTitle(IDS_APPNAME);
 494                 sysProgressDlg.SetLine(1, CString(MAKEINTRESOURCE(IDS_PROC_COMMIT_PREPARECOMMIT)));
 495                 sysProgressDlg.SetLine(2, CString(MAKEINTRESOURCE(IDS_PROC_COMMIT_UPDATEINDEX)));
 496                 sysProgressDlg.SetProgress(progress, maxProgress);
 497                 AfxGetThread()->PumpMessage(); // process messages, in order to avoid freezing
 498         }
 499
 500         BOOL cancel = FALSE;
 501         return mgt.Execute(cancel);
 502 }
 503
 504 void CCommitDlg::OnOK()
 505 {
 506         if (m_bBlock)
 507                 return;
 508         if (m_bThreadRunning)
 509         {
 510                 m_bCancelled = true;
 511                 InterlockedExchange(&m_bRunThread, FALSE);
 512                 WaitForSingleObject(m_pThread->m_hThread, 1000);
 513                 if (m_bThreadRunning)
 514                 {
 515                         // we gave the thread a chance to quit. Since the thread didn't
 516                         // listen to us we have to kill it.
 517                         TerminateThread(m_pThread->m_hThread, (DWORD)-1);
 518                         InterlockedExchange(&m_bThreadRunning, FALSE);
 519                 }
 520         }
 521         this->UpdateData();
 522
 523         if (m_bCreateNewBranch)
 524         {
 525                 if (!g_Git.IsBranchNameValid(m_sCreateNewBranch))
 526                 {
 527                         ShowEditBalloon(IDC_NEWBRANCH, IDS_B_T_NOTEMPTY, TTI_ERROR);
 528                         return;
 529                 }
 530                 if (g_Git.BranchTagExists(m_sCreateNewBranch))
 531                 {
 532                         // branch already exists
 533                         CString msg;
 534                         msg.LoadString(IDS_B_EXISTS);
 535                         msg += _T(" ") + CString(MAKEINTRESOURCE(IDS_B_DELETEORDIFFERENTNAME));
 536                         ShowEditBalloon(IDC_NEWBRANCH, msg, CString(MAKEINTRESOURCE(IDS_WARN_WARNING)));
 537                         return;
 538                 }
 539                 if (g_Git.BranchTagExists(m_sCreateNewBranch, false))
 540                 {
 541                         // tag with the same name exists -> shortref is ambiguous
 542                         if (CMessageBox::Show(m_hWnd, IDS_B_SAMETAGNAMEEXISTS, IDS_APPNAME, 2, IDI_EXCLAMATION, IDS_CONTINUEBUTTON, IDS_ABORTBUTTON) == 2)
 543                                 return;
 544                 }
 545         }
 546
 547         CString id;
 548         GetDlgItemText(IDC_BUGID, id);
 549         if (!m_ProjectProperties.CheckBugID(id))
 550         {
 551                 ShowEditBalloon(IDC_BUGID, IDS_COMMITDLG_ONLYNUMBERS, TTI_ERROR);
 552                 return;
 553         }
 554         m_sLogMessage = m_cLogMessage.GetText();
 555         if ( m_sLogMessage.IsEmpty() )
 556         {
 557                 // no message entered, go round again
 558                 CMessageBox::Show(this->m_hWnd, IDS_COMMITDLG_NOMESSAGE, IDS_APPNAME, MB_OK | MB_ICONERROR);
 559                 return;
 560         }
 561         if ((m_ProjectProperties.bWarnIfNoIssue) && (id.IsEmpty() && !m_ProjectProperties.HasBugID(m_sLogMessage)))
 562         {
 563                 if (CMessageBox::Show(this->m_hWnd, IDS_COMMITDLG_NOISSUEWARNING, IDS_APPNAME, MB_YESNO | MB_ICONWARNING)!=IDYES)
 564                         return;
 565         }
 566
 567         if (m_ProjectProperties.bWarnNoSignedOffBy == TRUE && m_cLogMessage.GetText().Find(GetSignedOffByLine()) == -1)
 568         {
 569                 UINT retval = CMessageBox::Show(this->m_hWnd, IDS_PROC_COMMIT_NOSIGNOFFLINE, IDS_APPNAME, 1, IDI_WARNING, IDS_PROC_COMMIT_ADDSIGNOFFBUTTON, IDS_PROC_COMMIT_NOADDSIGNOFFBUTTON, IDS_ABORTBUTTON);
 570                 if (retval == 1)
 571                 {
 572                         OnBnClickedSignOff();
 573                         m_sLogMessage = m_cLogMessage.GetText();
 574                 }
 575                 else if (retval == 3)
 576                         return;
 577         }
 578
 579         int nListItems = m_ListCtrl.GetItemCount();
 580         bool needResetIndex = false;
 581         for (int i = 0; i < nListItems && !m_bCommitMessageOnly; ++i)
 582         {
 583                 CTGitPath *entry = (CTGitPath *)m_ListCtrl.GetItemData(i);
 584                 if (!entry->m_Checked && !(entry->m_Action & CTGitPath::LOGACTIONS_UNVER))
 585                         needResetIndex = true;
 586                 if (!entry->m_Checked || !entry->IsDirectory())
 587                         continue;
 588
 589                 bool dirty = false;
 590                 if (entry->m_Action & CTGitPath::LOGACTIONS_UNVER)
 591                 {
 592                         CGit subgit;
 593                         subgit.m_CurrentDir = g_Git.m_CurrentDir + _T("\\") + entry->GetWinPathString();
 594                         CString subcmdout;
 595                         subgit.Run(_T("git.exe status --porcelain"), &subcmdout, CP_UTF8);
 596                         dirty = !subcmdout.IsEmpty();
 597                 }
 598                 else
 599                 {
 600                         CString cmd, cmdout;
 601                         cmd.Format(_T("git.exe diff -- \"%s\""), entry->GetWinPathString());
 602                         g_Git.Run(cmd, &cmdout, CP_UTF8);
 603                         dirty = cmdout.Right(7) == _T("-dirty\n");
 604                 }
 605
 606                 if (dirty)
 607                 {
 608                         CString message;
 609                         message.Format(CString(MAKEINTRESOURCE(IDS_COMMITDLG_SUBMODULEDIRTY)), entry->GetGitPathString());
 610                         int result = CMessageBox::Show(m_hWnd, message, _T("TortoiseGit"), 1, IDI_QUESTION, CString(MAKEINTRESOURCE(IDS_PROGRS_CMD_COMMIT)), CString(MAKEINTRESOURCE(IDS_MSGBOX_IGNORE)), CString(MAKEINTRESOURCE(IDS_MSGBOX_CANCEL)));
 611                         if (result == 1)
 612                         {
 613                                 CString cmdCommit;
 614                                 cmdCommit.Format(_T("/command:commit /path:\"%s\\%s\""), g_Git.m_CurrentDir, entry->GetWinPathString());
 615                                 CAppUtils::RunTortoiseGitProc(cmdCommit);
 616                                 return;
 617                         }
 618                         else if (result == 2)
 619                                 continue;
 620                         else
 621                                 return;
 622                 }
 623         }
 624
 625         if (!m_bCommitMessageOnly)
 626                 m_ListCtrl.WriteCheckedNamesToPathList(m_selectedPathList);
 627         m_pathwatcher.Stop();
 628         InterlockedExchange(&m_bBlock, TRUE);
 629         CDWordArray arDeleted;
 630         //first add all the unversioned files the user selected
 631         //and check if all versioned files are selected
 632         int nchecked = 0;
 633         m_bRecursive = true;
 634
 635         CTGitPathList itemsToAdd;
 636         CTGitPathList itemsToRemove;
 637         CMassiveGitTask mgtReAddAfterCommit(_T("add --ignore-errors -f"));
 638
 639         CString cmd;
 640         CString out;
 641
 642         bool bAddSuccess=true;
 643         bool bCloseCommitDlg=false;
 644
 645         CSysProgressDlg sysProgressDlg;
 646         if (nListItems >= 25)
 647         {
 648                 sysProgressDlg.SetTitle(CString(MAKEINTRESOURCE(IDS_PROC_COMMIT_PREPARECOMMIT)));
 649                 sysProgressDlg.SetLine(1, CString(MAKEINTRESOURCE(IDS_PROC_COMMIT_UPDATEINDEX)));
 650                 sysProgressDlg.SetTime(true);
 651                 sysProgressDlg.SetShowProgressBar(true);
 652                 sysProgressDlg.ShowModal(this, true);
 653         }
 654
 655         CBlockCacheForPath cacheBlock(g_Git.m_CurrentDir);
 656         DWORD currentTicks = GetTickCount();
 657
 658         if (g_Git.UsingLibGit2(CGit::GIT_CMD_COMMIT_UPDATE_INDEX))
 659         {
 660                 /*
 661                         Do not use the libgit2 implementation right now, since it has several flaws:
 662                         * https://github.com/libgit2/libgit2/issues/1397: crlf issue
 663                         * http://code.google.com/p/tortoisegit/issues/detail?id=1690: possible access denied problem
 664                         * https://github.com/libgit2/libgit2/pull/1291: git.exe path is searched again and again
 665                         * changes to x-bit are not correctly committed
 666                 */
 667                 bAddSuccess = false;
 668                 do
 669                 {
 670                         git_repository *repository = nullptr;
 671                         CStringA gitdir = CUnicodeUtils::GetMulti(CTGitPath(g_Git.m_CurrentDir).GetGitPathString(), CP_UTF8);
 672                         if (git_repository_open(&repository, gitdir.GetBuffer()))
 673                         {
 674                                 gitdir.ReleaseBuffer();
 675                                 CMessageBox::Show(m_hWnd, CGit::GetLibGit2LastErr(_T("Could not open repository.")), _T("TortoiseGit"), MB_OK | MB_ICONERROR);
 676                                 break;
 677                         }
 678                         gitdir.ReleaseBuffer();
 679
 680                         CGitHash revHash;
 681                         CString revRef = _T("HEAD");
 682                         if (m_bCommitAmend && !m_bAmendDiffToLastCommit)
 683                                 revRef = _T("HEAD~1");
 684                         if (g_Git.GetHash(revHash, revRef))
 685                         {
 686                                 git_repository_free(repository);
 687                                 MessageBox(g_Git.GetLibGit2LastErr(_T("Could not get HEAD hash after committing.")), _T("TortoiseGit"), MB_ICONERROR);
 688                                 break;
 689                         }
 690
 691                         git_commit *commit = nullptr;
 692                         if (!revHash.IsEmpty() && needResetIndex && git_commit_lookup(&commit, repository, (const git_oid*)revHash.m_hash))
 693                         {
 694                                 git_repository_free(repository);
 695                                 CMessageBox::Show(m_hWnd, CGit::GetLibGit2LastErr(_T("Could not get last commit.")), _T("TortoiseGit"), MB_OK | MB_ICONERROR);
 696                                 break;
 697                         }
 698
 699                         git_tree *tree = nullptr;
 700                         if (!revHash.IsEmpty() && needResetIndex && git_commit_tree(&tree, commit))
 701                         {
 702                                 git_commit_free(commit);
 703                                 git_repository_free(repository);
 704                                 CMessageBox::Show(m_hWnd, CGit::GetLibGit2LastErr(_T("Could not read tree of commit.")), _T("TortoiseGit"), MB_OK | MB_ICONERROR);
 705                                 break;
 706                         }
 707
 708                         git_index *index = nullptr;
 709                         if (git_repository_index(&index, repository))
 710                         {
 711                                 if (tree != nullptr)
 712                                         git_tree_free(tree);
 713                                 if (commit != nullptr)
 714                                         git_commit_free(commit);
 715                                 git_repository_free(repository);
 716                                 CMessageBox::Show(m_hWnd, CGit::GetLibGit2LastErr(_T("Could not get the repository index.")), _T("TortoiseGit"), MB_OK | MB_ICONERROR);
 717                                 break;
 718                         }
 719
 720                         // reset index to the one of the reference commit (HEAD or HEAD~1)
 721                         if (!revHash.IsEmpty() && needResetIndex && git_index_read_tree(index, tree))
 722                         {
 723                                 git_index_free(index);
 724                                 git_tree_free(tree);
 725                                 git_commit_free(commit);
 726                                 git_repository_free(repository);
 727                                 CMessageBox::Show(m_hWnd, CGit::GetLibGit2LastErr(_T("Could not read the tree into the index.")), _T("TortoiseGit"), MB_OK | MB_ICONERROR);
 728                                 break;
 729                         }
 730                         else if (!revHash.IsEmpty() && !needResetIndex)
 731                         {
 732                                 git_index_read(index, true);
 733                         }
 734
 735                         bAddSuccess = true;
 736
 737                         for (int j = 0; j < nListItems; ++j)
 738                         {
 739                                 CTGitPath *entry = (CTGitPath*)m_ListCtrl.GetItemData(j);
 740
 741                                 if (sysProgressDlg.IsVisible())
 742                                 {
 743                                         if (GetTickCount() - currentTicks > 1000 || j == nListItems - 1 || j == 0)
 744                                         {
 745                                                 sysProgressDlg.SetLine(2, entry->GetGitPathString(), true);
 746                                                 sysProgressDlg.SetProgress(j, nListItems);
 747                                                 AfxGetThread()->PumpMessage(); // process messages, in order to avoid freezing; do not call this too often: this takes time!
 748                                                 currentTicks = GetTickCount();
 749                                         }
 750                                 }
 751
 752                                 CStringA filePathA = CUnicodeUtils::GetMulti(entry->GetGitPathString(), CP_UTF8);
 753
 754                                 if (entry->m_Checked && !m_bCommitMessageOnly)
 755                                 {
 756                                         if (entry->IsDirectory())
 757                                         {
 758                                                 git_submodule *submodule = nullptr;
 759                                                 if (git_submodule_lookup(&submodule, repository, filePathA.GetBuffer()))
 760                                                 {
 761                                                         filePathA.ReleaseBuffer();
 762                                                         bAddSuccess = false;
 763                                                         CMessageBox::Show(m_hWnd, CGit::GetLibGit2LastErr(_T("Could not open submodule \"") + entry->GetGitPathString() + _T("\".")), _T("TortoiseGit"), MB_OK | MB_ICONERROR);
 764                                                         break;
 765                                                 }
 766                                                 filePathA.ReleaseBuffer();
 767                                                 if (git_submodule_add_to_index(submodule, FALSE))
 768                                                 {
 769                                                         bAddSuccess = false;
 770                                                         CMessageBox::Show(m_hWnd, CGit::GetLibGit2LastErr(_T("Could not add submodule \"") + entry->GetGitPathString() + _T("\" to index.")), _T("TortoiseGit"), MB_OK | MB_ICONERROR);
 771                                                         break;
 772                                                 }
 773                                         }
 774                                         else if (entry->m_Action & CTGitPath::LOGACTIONS_DELETED)
 775                                         {
 776                                                 git_index_remove_bypath(index, filePathA.GetBuffer()); // ignore error
 777                                                 filePathA.ReleaseBuffer();
 778                                         }
 779                                         else
 780                                         {
 781                                                 if (git_index_add_bypath(index, filePathA.GetBuffer()))
 782                                                 {
 783                                                         filePathA.ReleaseBuffer();
 784                                                         bAddSuccess = false;
 785                                                         CMessageBox::Show(m_hWnd, CGit::GetLibGit2LastErr(_T("Could not add \"") + entry->GetGitPathString() + _T("\" to index.")), _T("TortoiseGit"), MB_OK | MB_ICONERROR);
 786                                                         break;
 787                                                 }
 788                                                 filePathA.ReleaseBuffer();
 789                                         }
 790
 791                                         if (entry->m_Action & CTGitPath::LOGACTIONS_REPLACED)
 792                                         {
 793                                                 git_index_remove_bypath(index, filePathA.GetBuffer()); // ignore error
 794                                                 filePathA.ReleaseBuffer();
 795                                         }
 796
 797                                         ++nchecked;
 798                                 }
 799                                 else if (entry->m_Action & CTGitPath::LOGACTIONS_ADDED || entry->m_Action & CTGitPath::LOGACTIONS_REPLACED)
 800                                         mgtReAddAfterCommit.AddFile(*entry);
 801
 802                                 if (sysProgressDlg.HasUserCancelled())
 803                                 {
 804                                         bAddSuccess = false;
 805                                         break;
 806                                 }
 807
 808                                 CShellUpdater::Instance().AddPathForUpdate(*entry);
 809                         }
 810                         if (bAddSuccess && git_index_write(index))
 811                                 bAddSuccess = false;
 812
 813                         git_index_free(index);
 814                         if (tree != nullptr)
 815                                 git_tree_free(tree);
 816                         if (commit != nullptr)
 817                                 git_commit_free(commit);
 818                         git_repository_free(repository);
 819                 } while (0);
 820         }
 821         else
 822         {
 823                 // ***************************************************
 824                 // ATTENTION: Similar code in RebaseDlg.cpp!!!
 825                 // ***************************************************
 826                 CMassiveGitTask mgtAdd(_T("add -f"));
 827                 CMassiveGitTask mgtUpdateIndexForceRemove(_T("update-index --force-remove"));
 828                 CMassiveGitTask mgtUpdateIndex(_T("update-index"));
 829                 CMassiveGitTask mgtRm(_T("rm --ignore-unmatch"));
 830                 CMassiveGitTask mgtRmFCache(_T("rm -f --cache"));
 831                 CString resetCmd = _T("reset");
 832                 if (m_bCommitAmend && !m_bAmendDiffToLastCommit)
 833                         resetCmd += _T(" HEAD~1");;
 834                 CMassiveGitTask mgtReset(resetCmd, TRUE, true);
 835                 for (int j = 0; j < nListItems; ++j)
 836                 {
 837                         CTGitPath *entry = (CTGitPath*)m_ListCtrl.GetItemData(j);
 838
 839                         if (entry->m_Checked && !m_bCommitMessageOnly)
 840                         {
 841                                 if (entry->m_Action & CTGitPath::LOGACTIONS_UNVER)
 842                                         mgtAdd.AddFile(entry->GetGitPathString());
 843                                 else if (entry->m_Action & CTGitPath::LOGACTIONS_DELETED)
 844                                         mgtUpdateIndexForceRemove.AddFile(entry->GetGitPathString());
 845                                 else
 846                                         mgtUpdateIndex.AddFile(entry->GetGitPathString());
 847
 848                                 if ((entry->m_Action & CTGitPath::LOGACTIONS_REPLACED) && !entry->GetGitOldPathString().IsEmpty())
 849                                         mgtRm.AddFile(entry->GetGitOldPathString());
 850
 851                                 ++nchecked;
 852                         }
 853                         else
 854                         {
 855                                 if (entry->m_Action & CTGitPath::LOGACTIONS_ADDED || entry->m_Action & CTGitPath::LOGACTIONS_REPLACED)
 856                                 {       //To init git repository, there are not HEAD, so we can use git reset command
 857                                         mgtRmFCache.AddFile(entry->GetGitPathString());
 858                                         mgtReAddAfterCommit.AddFile(*entry);
 859
 860                                         if (entry->m_Action & CTGitPath::LOGACTIONS_REPLACED && !entry->GetGitOldPathString().IsEmpty())
 861                                                 mgtReset.AddFile(entry->GetGitOldPathString());
 862                                 }
 863                                 else if (!(entry->m_Action & CTGitPath::LOGACTIONS_UNVER))
 864                                         mgtReset.AddFile(entry->GetGitPathString());
 865                         }
 866
 867                         if (sysProgressDlg.HasUserCancelled())
 868                         {
 869                                 bAddSuccess = false;
 870                                 break;
 871                         }
 872                 }
 873
 874                 CMassiveGitTask tasks[] = { mgtAdd, mgtUpdateIndexForceRemove, mgtUpdateIndex, mgtRm, mgtRmFCache, mgtReset };
 875                 int progress = 0, maxProgress = 0;
 876                 for (int j = 0; j < _countof(tasks); ++j)
 877                         maxProgress += tasks[j].GetListCount();
 878                 for (int j = 0; j < _countof(tasks); ++j)
 879                         bAddSuccess = bAddSuccess && UpdateIndex(tasks[j], sysProgressDlg, progress += tasks[j].GetListCount(), maxProgress);
 880
 881                 if (sysProgressDlg.HasUserCancelled())
 882                         bAddSuccess = false;
 883
 884                 for (int j = 0; bAddSuccess && j < nListItems; ++j)
 885                         CShellUpdater::Instance().AddPathForUpdate(*(CTGitPath*)m_ListCtrl.GetItemData(j));
 886         }
 887
 888         if (sysProgressDlg.HasUserCancelled())
 889                 bAddSuccess = false;
 890
 891         //sysProgressDlg.Stop();
 892
 893         if (bAddSuccess && m_bCreateNewBranch)
 894         {
 895                 if (g_Git.Run(_T("git.exe branch ") + m_sCreateNewBranch, &out, CP_UTF8))
 896                 {
 897                         MessageBox(_T("Creating new branch failed:\n") + out, _T("TortoiseGit"), MB_OK | MB_ICONERROR);
 898                         bAddSuccess = false;
 899                 }
 900                 if (g_Git.Run(_T("git.exe checkout ") + m_sCreateNewBranch + _T(" --"), &out, CP_UTF8))
 901                 {
 902                         MessageBox(_T("Switching to new branch failed:\n") + out, _T("TortoiseGit"), MB_OK | MB_ICONERROR);
 903                         bAddSuccess = false;
 904                 }
 905         }
 906
 907         if (bAddSuccess && CheckHeadDetach())
 908                 bAddSuccess = false;
 909
 910         m_sBugID.Trim();
 911         CString sExistingBugID = m_ProjectProperties.FindBugID(m_sLogMessage);
 912         sExistingBugID.Trim();
 913         if (!m_sBugID.IsEmpty() && m_sBugID.Compare(sExistingBugID))
 914         {
 915                 m_sBugID.Replace(_T(", "), _T(","));
 916                 m_sBugID.Replace(_T(" ,"), _T(","));
 917                 CString sBugID = m_ProjectProperties.sMessage;
 918                 sBugID.Replace(_T("%BUGID%"), m_sBugID);
 919                 if (m_ProjectProperties.bAppend)
 920                         m_sLogMessage += _T("\n") + sBugID + _T("\n");
 921                 else
 922                         m_sLogMessage = sBugID + _T("\n") + m_sLogMessage;
 923         }
 924
 925         // now let the bugtraq plugin check the commit message
 926         CComPtr<IBugTraqProvider2> pProvider2 = NULL;
 927         if (m_BugTraqProvider)
 928         {
 929                 HRESULT hr = m_BugTraqProvider.QueryInterface(&pProvider2);
 930                 if (SUCCEEDED(hr))
 931                 {
 932                         BSTR temp = NULL;
 933                         CString common = g_Git.m_CurrentDir;
 934                         BSTR repositoryRoot = common.AllocSysString();
 935                         BSTR parameters = m_bugtraq_association.GetParameters().AllocSysString();
 936                         BSTR commonRoot = SysAllocString(m_pathList.GetCommonRoot().GetDirectory().GetWinPath());
 937                         BSTR commitMessage = m_sLogMessage.AllocSysString();
 938                         SAFEARRAY *pathList = SafeArrayCreateVector(VT_BSTR, 0, m_selectedPathList.GetCount());
 939
 940                         for (LONG index = 0; index < m_selectedPathList.GetCount(); ++index)
 941                                 SafeArrayPutElement(pathList, &index, m_selectedPathList[index].GetGitPathString().AllocSysString());
 942
 943                         if (FAILED(hr = pProvider2->CheckCommit(GetSafeHwnd(), parameters, repositoryRoot, commonRoot, pathList, commitMessage, &temp)))
 944                         {
 945                                 COMError ce(hr);
 946                                 CString sErr;
 947                                 sErr.Format(IDS_ERR_FAILEDISSUETRACKERCOM, m_bugtraq_association.GetProviderName(), ce.GetMessageAndDescription().c_str());
 948                                 CMessageBox::Show(m_hWnd, sErr, _T("TortoiseGit"), MB_ICONERROR);
 949                         }
 950                         else
 951                         {
 952                                 CString sError = temp;
 953                                 if (!sError.IsEmpty())
 954                                 {
 955                                         CMessageBox::Show(m_hWnd, sError, _T("TortoiseGit"), MB_ICONERROR);
 956                                         return;
 957                                 }
 958                                 SysFreeString(temp);
 959                         }
 960                 }
 961         }
 962
 963         if (m_bCommitMessageOnly || bAddSuccess && (nchecked || m_bCommitAmend ||  CTGitPath(g_Git.m_CurrentDir).IsMergeActive()))
 964         {
 965                 bCloseCommitDlg = true;
 966
 967                 CString tempfile=::GetTempFile();
 968
 969                 CAppUtils::SaveCommitUnicodeFile(tempfile,m_sLogMessage);
 970
 971                 CTGitPath path=g_Git.m_CurrentDir;
 972
 973                 BOOL IsGitSVN = path.GetAdminDirMask() & ITEMIS_GITSVN;
 974
 975                 out =_T("");
 976                 CString amend;
 977                 if(this->m_bCommitAmend)
 978                 {
 979                         amend=_T("--amend");
 980                 }
 981                 CString dateTime;
 982                 if (m_bSetCommitDateTime)
 983                 {
 984                         CTime date, time;
 985                         m_CommitDate.GetTime(date);
 986                         m_CommitTime.GetTime(time);
 987                         dateTime.Format(_T("--date=%sT%s"), date.Format(_T("%Y-%m-%d")), time.Format(_T("%H:%M:%S")));
 988                 }
 989                 CString author;
 990                 if (m_bSetAuthor)
 991                         author.Format(_T("--author=\"%s\""), m_sAuthor);
 992                 CString allowEmpty = m_bCommitMessageOnly ? _T("--allow-empty") : _T("");
 993                 cmd.Format(_T("git.exe commit %s %s %s %s -F \"%s\""), author, dateTime, amend, allowEmpty, tempfile);
 994
 995                 CCommitProgressDlg progress;
 996                 progress.m_bBufferAll=true; // improve show speed when there are many file added.
 997                 progress.m_GitCmd=cmd;
 998                 progress.m_bShowCommand = FALSE;        // don't show the commit command
 999                 progress.m_PreText = out;                       // show any output already generated in log window
1000                 progress.m_bAutoCloseOnSuccess = m_bAutoClose;
1001
1002                 int indexPull = -1;
1003                 int indexReCommit = -1;
1004                 int indexTag = -1;
1005
1006                 if (!m_bNoPostActions && !m_bAutoClose)
1007                 {
1008                         if (IsGitSVN)
1009                                 progress.m_PostCmdList.Add(CString(MAKEINTRESOURCE(IDS_MENUSVNDCOMMIT)));
1010                         progress.m_PostCmdList.Add(CString(MAKEINTRESOURCE(IDS_MENUPUSH)));
1011                         indexPull = (int)progress.m_PostCmdList.Add(CString(MAKEINTRESOURCE(IDS_MENUPULL)));
1012                         indexReCommit = (int)progress.m_PostCmdList.Add(CString(MAKEINTRESOURCE(IDS_PROC_COMMIT_RECOMMIT)));
1013                         indexTag = (int)progress.m_PostCmdList.Add(CString(MAKEINTRESOURCE(IDS_MENUTAG)));
1014                 }
1015
1016                 INT_PTR userResponse = progress.DoModal();
1017
1018                 if(progress.m_GitStatus || userResponse == (IDC_PROGRESS_BUTTON1 + indexReCommit))
1019                 {
1020                         bCloseCommitDlg = false;
1021                         if (userResponse == IDC_PROGRESS_BUTTON1 + indexReCommit)
1022                         {
1023                                 this->m_sLogMessage.Empty();
1024                                 m_cLogMessage.SetText(m_sLogMessage);
1025                                 m_bCreateNewBranch = FALSE;
1026                         }
1027
1028                         m_bCommitAmend = FALSE;
1029                         UpdateData(FALSE);
1030                         this->Refresh();
1031                         this->BringWindowToTop();
1032                 }
1033                 else if (userResponse == IDC_PROGRESS_BUTTON1 + indexTag)
1034                 {
1035                         m_bCreateTagAfterCommit=true;
1036                 }
1037                 else if (userResponse == IDC_PROGRESS_BUTTON1 + indexPull)
1038                         m_bPullAfterCommit = TRUE;
1039                 else if (userResponse >= IDC_PROGRESS_BUTTON1 && userResponse < IDC_PROGRESS_BUTTON1 + indexPull)
1040                 {
1041                         // User pressed 'DCommit' or 'Push' button after successful commit.
1042                         m_bPushAfterCommit=true;
1043                         if (userResponse == IDC_PROGRESS_BUTTON1 && IsGitSVN)
1044                                 m_PostCmd = GIT_POST_CMD_DCOMMIT;
1045                         else
1046                                 m_PostCmd = GIT_POST_CMD_PUSH;
1047                 }
1048
1049                 CFile::Remove(tempfile);
1050
1051                 if (m_BugTraqProvider && progress.m_GitStatus == 0)
1052                 {
1053                         CComPtr<IBugTraqProvider2> pProvider = NULL;
1054                         HRESULT hr = m_BugTraqProvider.QueryInterface(&pProvider);
1055                         if (SUCCEEDED(hr))
1056                         {
1057                                 BSTR commonRoot = SysAllocString(g_Git.m_CurrentDir);
1058                                 SAFEARRAY *pathList = SafeArrayCreateVector(VT_BSTR, 0,this->m_selectedPathList.GetCount());
1059
1060                                 for (LONG index = 0; index < m_selectedPathList.GetCount(); ++index)
1061                                         SafeArrayPutElement(pathList, &index, m_selectedPathList[index].GetGitPathString().AllocSysString());
1062
1063                                 BSTR logMessage = m_sLogMessage.AllocSysString();
1064
1065                                 CGitHash hash;
1066                                 if (g_Git.GetHash(hash, _T("HEAD")))
1067                                         MessageBox(g_Git.GetGitLastErr(_T("Could not get HEAD hash after committing.")), _T("TortoiseGit"), MB_ICONERROR);
1068                                 LONG version = g_Git.Hash2int(hash);
1069
1070                                 BSTR temp = NULL;
1071                                 if (FAILED(hr = pProvider->OnCommitFinished(GetSafeHwnd(),
1072                                         commonRoot,
1073                                         pathList,
1074                                         logMessage,
1075                                         (LONG)version,
1076                                         &temp)))
1077                                 {
1078                                         CString sErr = temp;
1079                                         if (!sErr.IsEmpty())
1080                                                 CMessageBox::Show(NULL,(sErr),_T("TortoiseGit"),MB_OK|MB_ICONERROR);
1081                                         else
1082                                         {
1083                                                 COMError ce(hr);
1084                                                 sErr.Format(IDS_ERR_FAILEDISSUETRACKERCOM, ce.GetSource().c_str(), ce.GetMessageAndDescription().c_str());
1085                                                 CMessageBox::Show(NULL,(sErr),_T("TortoiseGit"),MB_OK|MB_ICONERROR);
1086                                         }
1087                                 }
1088
1089                                 SysFreeString(temp);
1090                         }
1091                 }
1092                 RestoreFiles(progress.m_GitStatus == 0);
1093                 if (((DWORD)CRegStdDWORD(_T("Software\\TortoiseGit\\ReaddUnselectedAddedFilesAfterCommit"), TRUE)) == TRUE)
1094                 {
1095                         BOOL cancel = FALSE;
1096                         mgtReAddAfterCommit.Execute(cancel);
1097                 }
1098         }
1099         else if(bAddSuccess)
1100         {
1101                 CMessageBox::Show(this->m_hWnd, IDS_ERROR_NOTHING_COMMIT, IDS_COMMIT_FINISH, MB_OK | MB_ICONINFORMATION);
1102                 bCloseCommitDlg=false;
1103         }
1104
1105         UpdateData();
1106         m_regAddBeforeCommit = m_bShowUnversioned;
1107         if (!GetDlgItem(IDC_WHOLE_PROJECT)->IsWindowEnabled())
1108                 m_bWholeProject = FALSE;
1109         m_regKeepChangelists = m_bKeepChangeList;
1110         m_regDoNotAutoselectSubmodules = m_bDoNotAutoselectSubmodules;
1111         if (!GetDlgItem(IDC_KEEPLISTS)->IsWindowEnabled())
1112                 m_bKeepChangeList = FALSE;
1113         InterlockedExchange(&m_bBlock, FALSE);
1114
1115         if (!m_sLogMessage.IsEmpty())
1116         {
1117                 m_History.AddEntry(m_sLogMessage);
1118                 m_History.Save();
1119         }
1120
1121         SaveSplitterPos();
1122
1123         if( bCloseCommitDlg )
1124                 CResizableStandAloneDialog::OnOK();
1125
1126         CShellUpdater::Instance().Flush();
1127 }
1128
1129 void CCommitDlg::SaveSplitterPos()
1130 {
1131         if (!IsIconic())
1132         {
1133                 CRegDWORD regPos = CRegDWORD(_T("Software\\TortoiseGit\\TortoiseProc\\ResizableState\\CommitDlgSizer"));
1134                 RECT rectSplitter;
1135                 m_wndSplitter.GetWindowRect(&rectSplitter);
1136                 ScreenToClient(&rectSplitter);
1137                 regPos = rectSplitter.top;
1138         }
1139 }
1140
1141 UINT CCommitDlg::StatusThreadEntry(LPVOID pVoid)
1142 {
1143         return ((CCommitDlg*)pVoid)->StatusThread();
1144 }
1145
1146 UINT CCommitDlg::StatusThread()
1147 {
1148         //get the status of all selected file/folders recursively
1149         //and show the ones which have to be committed to the user
1150         //in a list control.
1151         InterlockedExchange(&m_bBlock, TRUE);
1152         InterlockedExchange(&m_bThreadRunning, TRUE);// so the main thread knows that this thread is still running
1153         InterlockedExchange(&m_bRunThread, TRUE);       // if this is set to FALSE, the thread should stop
1154
1155         m_pathwatcher.Stop();
1156
1157         m_ListCtrl.SetBusy(true);
1158         g_Git.RefreshGitIndex();
1159
1160         m_bCancelled = false;
1161
1162         DialogEnableWindow(IDOK, false);
1163         DialogEnableWindow(IDC_SHOWUNVERSIONED, false);
1164         DialogEnableWindow(IDC_WHOLE_PROJECT, false);
1165         DialogEnableWindow(IDC_NOAUTOSELECTSUBMODULES, false);
1166         GetDlgItem(IDC_EXTERNALWARNING)->ShowWindow(SW_HIDE);
1167         DialogEnableWindow(IDC_EXTERNALWARNING, false);
1168         DialogEnableWindow(IDC_COMMIT_AMEND, FALSE);
1169         DialogEnableWindow(IDC_COMMIT_AMENDDIFF, FALSE);
1170         // read the list of recent log entries before querying the WC for status
1171         // -> the user may select one and modify / update it while we are crawling the WC
1172
1173         DialogEnableWindow(IDC_CHECKALL, false);
1174         DialogEnableWindow(IDC_CHECKNONE, false);
1175         DialogEnableWindow(IDC_CHECKUNVERSIONED, false);
1176         DialogEnableWindow(IDC_CHECKVERSIONED, false);
1177         DialogEnableWindow(IDC_CHECKADDED, false);
1178         DialogEnableWindow(IDC_CHECKDELETED, false);
1179         DialogEnableWindow(IDC_CHECKMODIFIED, false);
1180         DialogEnableWindow(IDC_CHECKFILES, false);
1181         DialogEnableWindow(IDC_CHECKSUBMODULES, false);
1182
1183         if (m_History.GetCount()==0)
1184         {
1185                 CString reg;
1186                 reg.Format(_T("Software\\TortoiseGit\\History\\commit%s"), (LPCTSTR)m_ListCtrl.m_sUUID);
1187                 reg.Replace(_T(':'),_T('_'));
1188                 m_History.Load(reg, _T("logmsgs"));
1189         }
1190
1191         // Initialise the list control with the status of the files/folders below us
1192         m_ListCtrl.Clear();
1193         BOOL success;
1194         CTGitPathList *pList;
1195         m_ListCtrl.m_amend = (m_bCommitAmend==TRUE || m_bForceCommitAmend) && (m_bAmendDiffToLastCommit==FALSE);
1196         m_ListCtrl.m_bDoNotAutoselectSubmodules = (m_bDoNotAutoselectSubmodules == TRUE);
1197
1198         if(m_bWholeProject)
1199                 pList=NULL;
1200         else
1201                 pList = &m_pathList;
1202
1203         success=m_ListCtrl.GetStatus(pList);
1204
1205         //m_ListCtrl.UpdateFileList(git_revnum_t(GIT_REV_ZERO));
1206         if(this->m_bShowUnversioned)
1207                 m_ListCtrl.UpdateFileList(CGitStatusListCtrl::FILELIST_UNVER,true,pList);
1208
1209         m_ListCtrl.CheckIfChangelistsArePresent(false);
1210
1211         DWORD dwShow = GITSLC_SHOWVERSIONEDBUTNORMALANDEXTERNALSFROMDIFFERENTREPOS | GITSLC_SHOWLOCKS | GITSLC_SHOWINCHANGELIST | GITSLC_SHOWDIRECTFILES;
1212         dwShow |= DWORD(m_regAddBeforeCommit) ? GITSLC_SHOWUNVERSIONED : 0;
1213         if (success)
1214         {
1215                 if (m_checkedPathList.GetCount())
1216                         m_ListCtrl.Show(dwShow, m_checkedPathList);
1217                 else
1218                 {
1219                         DWORD dwCheck = m_bSelectFilesForCommit ? dwShow : 0;
1220                         dwCheck &=~(CTGitPath::LOGACTIONS_UNVER); //don't check unversion file default.
1221                         m_ListCtrl.Show(dwShow, dwCheck);
1222                         m_bSelectFilesForCommit = true;
1223                 }
1224
1225                 if (m_ListCtrl.HasExternalsFromDifferentRepos())
1226                 {
1227                         GetDlgItem(IDC_EXTERNALWARNING)->ShowWindow(SW_SHOW);
1228                         DialogEnableWindow(IDC_EXTERNALWARNING, TRUE);
1229                 }
1230
1231                 SetDlgItemText(IDC_COMMIT_TO, g_Git.GetCurrentBranch());
1232                 m_tooltips.AddTool(GetDlgItem(IDC_STATISTICS), m_ListCtrl.GetStatisticsString());
1233         }
1234         if (!success)
1235         {
1236                 if (!m_ListCtrl.GetLastErrorMessage().IsEmpty())
1237                         m_ListCtrl.SetEmptyString(m_ListCtrl.GetLastErrorMessage());
1238                 m_ListCtrl.Show(dwShow);
1239         }
1240
1241         CString dotGitPath;
1242         g_GitAdminDir.GetAdminDirPath(g_Git.m_CurrentDir, dotGitPath);
1243         if ((m_ListCtrl.GetItemCount()==0)&&(m_ListCtrl.HasUnversionedItems())
1244                  && !PathFileExists(dotGitPath + _T("MERGE_HEAD")))
1245         {
1246                 CString temp;
1247                 temp.LoadString(IDS_COMMITDLG_NOTHINGTOCOMMITUNVERSIONED);
1248                 if (CMessageBox::ShowCheck(m_hWnd, temp, _T("TortoiseGit"), MB_ICONINFORMATION | MB_YESNO, _T("NothingToCommitShowUnversioned"), NULL)==IDYES)
1249                 {
1250                         m_bShowUnversioned = TRUE;
1251                         GetDlgItem(IDC_SHOWUNVERSIONED)->SendMessage(BM_SETCHECK, BST_CHECKED);
1252                         DWORD dwShow = (DWORD)(GITSLC_SHOWVERSIONEDBUTNORMALANDEXTERNALSFROMDIFFERENTREPOS | GITSLC_SHOWUNVERSIONED | GITSLC_SHOWLOCKS);
1253                         m_ListCtrl.UpdateFileList(CGitStatusListCtrl::FILELIST_UNVER);
1254                         m_ListCtrl.Show(dwShow,dwShow&(~CTGitPath::LOGACTIONS_UNVER));
1255                 }
1256         }
1257
1258         SetDlgTitle();
1259
1260         m_autolist.clear();
1261         // we don't have to block the commit dialog while we fetch the
1262         // auto completion list.
1263         m_pathwatcher.ClearChangedPaths();
1264         InterlockedExchange(&m_bBlock, FALSE);
1265         if ((DWORD)CRegDWORD(_T("Software\\TortoiseGit\\Autocompletion"), TRUE)==TRUE)
1266         {
1267                 m_ListCtrl.Block(TRUE, TRUE);
1268                 GetAutocompletionList();
1269                 m_ListCtrl.Block(FALSE, FALSE);
1270         }
1271         SendMessage(WM_UPDATEOKBUTTON);
1272         if (m_bRunThread)
1273         {
1274                 DialogEnableWindow(IDC_SHOWUNVERSIONED, true);
1275                 DialogEnableWindow(IDC_WHOLE_PROJECT, true);
1276                 DialogEnableWindow(IDC_NOAUTOSELECTSUBMODULES, true);
1277                 if (m_ListCtrl.HasChangeLists())
1278                         DialogEnableWindow(IDC_KEEPLISTS, true);
1279                 if (m_ListCtrl.HasLocks())
1280                         DialogEnableWindow(IDC_WHOLE_PROJECT, true);
1281
1282                 // activate amend checkbox (if necessary)
1283                 if (g_Git.IsInitRepos())
1284                 {
1285                         m_bCommitAmend = FALSE;
1286                         SendMessage(WM_UPDATEDATAFALSE);
1287                 }
1288                 else
1289                 {
1290                         if (m_bForceCommitAmend)
1291                         {
1292                                 GetDlgItem(IDC_COMMIT_AMENDDIFF)->ShowWindow(SW_SHOW);
1293                                 m_bCommitAmend = TRUE;
1294                                 SendMessage(WM_UPDATEDATAFALSE);
1295                         }
1296                         else
1297                                 GetDlgItem(IDC_COMMIT_AMEND)->EnableWindow(TRUE);
1298
1299                         CGitHash hash;
1300                         if (g_Git.GetHash(hash, _T("HEAD")))
1301                         {
1302                                 MessageBox(g_Git.GetGitLastErr(_T("Could not get HEAD hash.")), _T("TortoiseGit"), MB_ICONERROR);
1303                         }
1304                         if (!hash.IsEmpty())
1305                         {
1306                                 GitRev headRevision;
1307                                 try
1308                                 {
1309                                         headRevision.GetParentFromHash(hash);
1310                                 }
1311                                 catch (char* msg)
1312                                 {
1313                                         CString err(msg);
1314                                         MessageBox(_T("Could not get parent from HEAD.\nlibgit reports:\n") + err, _T("TortoiseGit"), MB_ICONERROR);
1315                                 }
1316                                 // do not allow to show diff to "last" revision if it has more that one parent
1317                                 if (headRevision.ParentsCount() != 1)
1318                                 {
1319                                         m_bAmendDiffToLastCommit = TRUE;
1320                                         SendMessage(WM_UPDATEDATAFALSE);
1321                                 }
1322                                 else
1323                                         GetDlgItem(IDC_COMMIT_AMENDDIFF)->EnableWindow(TRUE);
1324                         }
1325                 }
1326
1327                 UpdateCheckLinks();
1328
1329                 // we have the list, now signal the main thread about it
1330                 SendMessage(WM_AUTOLISTREADY);  // only send the message if the thread wasn't told to quit!
1331         }
1332
1333         InterlockedExchange(&m_bRunThread, FALSE);
1334         InterlockedExchange(&m_bThreadRunning, FALSE);
1335         // force the cursor to normal
1336         RefreshCursor();
1337
1338         return 0;
1339 }
1340
1341 void CCommitDlg::SetDlgTitle()
1342 {
1343         if (m_sTitle.IsEmpty())
1344                 GetWindowText(m_sTitle);
1345
1346         if (m_bWholeProject)
1347                 CAppUtils::SetWindowTitle(m_hWnd, g_Git.m_CurrentDir, m_sTitle);
1348         else
1349         {
1350                 if (m_pathList.GetCount() == 1)
1351                         CAppUtils::SetWindowTitle(m_hWnd, (g_Git.m_CurrentDir + _T("\\") + m_pathList[0].GetUIPathString()).TrimRight('\\'), m_sTitle);
1352                 else
1353                         CAppUtils::SetWindowTitle(m_hWnd, g_Git.m_CurrentDir + _T("\\") + m_ListCtrl.GetCommonDirectory(false), m_sTitle);
1354         }
1355 }
1356
1357 void CCommitDlg::OnCancel()
1358 {
1359         m_bCancelled = true;
1360         m_pathwatcher.Stop();
1361
1362         if (m_bThreadRunning)
1363         {
1364                 InterlockedExchange(&m_bRunThread, FALSE);
1365                 WaitForSingleObject(m_pThread->m_hThread, 1000);
1366                 if (m_bThreadRunning)
1367                 {
1368                         // we gave the thread a chance to quit. Since the thread didn't
1369                         // listen to us we have to kill it.
1370                         TerminateThread(m_pThread->m_hThread, (DWORD)-1);
1371                         InterlockedExchange(&m_bThreadRunning, FALSE);
1372                 }
1373         }
1374         UpdateData();
1375         m_sBugID.Trim();
1376         m_sLogMessage = m_cLogMessage.GetText();
1377         if (!m_sBugID.IsEmpty())
1378         {
1379                 m_sBugID.Replace(_T(", "), _T(","));
1380                 m_sBugID.Replace(_T(" ,"), _T(","));
1381                 CString sBugID = m_ProjectProperties.sMessage;
1382                 sBugID.Replace(_T("%BUGID%"), m_sBugID);
1383                 if (m_ProjectProperties.bAppend)
1384                         m_sLogMessage += _T("\n") + sBugID + _T("\n");
1385                 else
1386                         m_sLogMessage = sBugID + _T("\n") + m_sLogMessage;
1387         }
1388         if ((m_ProjectProperties.sLogTemplate.Compare(m_sLogMessage) != 0) && !m_sLogMessage.IsEmpty())
1389         {
1390                 m_History.AddEntry(m_sLogMessage);
1391                 m_History.Save();
1392         }
1393         RestoreFiles();
1394         SaveSplitterPos();
1395         CResizableStandAloneDialog::OnCancel();
1396 }
1397
1398 BOOL CCommitDlg::PreTranslateMessage(MSG* pMsg)
1399 {
1400         if (!m_bBlock)
1401                 m_tooltips.RelayEvent(pMsg);
1402
1403         if (m_hAccel)
1404         {
1405                 int ret = TranslateAccelerator(m_hWnd, m_hAccel, pMsg);
1406                 if (ret)
1407                         return TRUE;
1408         }
1409
1410         if (pMsg->message == WM_KEYDOWN)
1411         {
1412                 switch (pMsg->wParam)
1413                 {
1414                 case VK_F5:
1415                         {
1416                                 if (m_bBlock)
1417                                         return CResizableStandAloneDialog::PreTranslateMessage(pMsg);
1418                                 Refresh();
1419                         }
1420                         break;
1421                 case VK_RETURN:
1422                         {
1423                                 if (GetAsyncKeyState(VK_CONTROL)&0x8000)
1424                                 {
1425                                         if ( GetDlgItem(IDOK)->IsWindowEnabled() )
1426                                         {
1427                                                 PostMessage(WM_COMMAND, IDOK);
1428                                         }
1429                                         return TRUE;
1430                                 }
1431                                 if ( GetFocus()==GetDlgItem(IDC_BUGID) )
1432                                 {
1433                                         // Pressing RETURN in the bug id control
1434                                         // moves the focus to the message
1435                                         GetDlgItem(IDC_LOGMESSAGE)->SetFocus();
1436                                         return TRUE;
1437                                 }
1438                         }
1439                         break;
1440                 }
1441         }
1442
1443         return CResizableStandAloneDialog::PreTranslateMessage(pMsg);
1444 }
1445
1446 void CCommitDlg::Refresh()
1447 {
1448         if (m_bThreadRunning)
1449                 return;
1450
1451         InterlockedExchange(&m_bBlock, TRUE);
1452         m_pThread = AfxBeginThread(StatusThreadEntry, this, THREAD_PRIORITY_NORMAL,0,CREATE_SUSPENDED);
1453         if (m_pThread==NULL)
1454         {
1455                 CMessageBox::Show(this->m_hWnd, IDS_ERR_THREADSTARTFAILED, IDS_APPNAME, MB_OK | MB_ICONERROR);
1456                 InterlockedExchange(&m_bBlock, FALSE);
1457         }
1458         else
1459         {
1460                 m_pThread->m_bAutoDelete = FALSE;
1461                 m_pThread->ResumeThread();
1462         }
1463 }
1464
1465 void CCommitDlg::OnBnClickedShowunversioned()
1466 {
1467         m_tooltips.Pop();       // hide the tooltips
1468         UpdateData();
1469         m_regAddBeforeCommit = m_bShowUnversioned;
1470         if (!m_bBlock)
1471         {
1472                 DWORD dwShow = m_ListCtrl.GetShowFlags();
1473                 if (DWORD(m_regAddBeforeCommit))
1474                         dwShow |= GITSLC_SHOWUNVERSIONED;
1475                 else
1476                         dwShow &= ~GITSLC_SHOWUNVERSIONED;
1477                 if(dwShow & GITSLC_SHOWUNVERSIONED)
1478                 {
1479                         if(m_bWholeProject)
1480                                 m_ListCtrl.GetStatus(NULL,false,false,true);
1481                         else
1482                                 m_ListCtrl.GetStatus(&this->m_pathList,false,false,true);
1483                 }
1484                 m_ListCtrl.Show(dwShow, 0, true, dwShow & ~(CTGitPath::LOGACTIONS_UNVER), true);
1485                 UpdateCheckLinks();
1486         }
1487 }
1488
1489 void CCommitDlg::OnStnClickedExternalwarning()
1490 {
1491         m_tooltips.Popup();
1492 }
1493
1494 void CCommitDlg::OnEnChangeLogmessage()
1495 {
1496         SendMessage(WM_UPDATEOKBUTTON);
1497 }
1498
1499 LRESULT CCommitDlg::OnGitStatusListCtrlItemCountChanged(WPARAM, LPARAM)
1500 {
1501 #if 0
1502         if ((m_ListCtrl.GetItemCount() == 0)&&(m_ListCtrl.HasUnversionedItems())&&(!m_bShowUnversioned))
1503         {
1504                 if (CMessageBox::Show(*this, IDS_COMMITDLG_NOTHINGTOCOMMITUNVERSIONED, IDS_APPNAME, MB_ICONINFORMATION | MB_YESNO)==IDYES)
1505                 {
1506                         m_bShowUnversioned = TRUE;
1507                         DWORD dwShow = GitSLC_SHOWVERSIONEDBUTNORMALANDEXTERNALSFROMDIFFERENTREPOS | GitSLC_SHOWUNVERSIONED | GitSLC_SHOWLOCKS;
1508                         m_ListCtrl.Show(dwShow);
1509                         UpdateData(FALSE);
1510                 }
1511         }
1512 #endif
1513         return 0;
1514 }
1515
1516 LRESULT CCommitDlg::OnGitStatusListCtrlNeedsRefresh(WPARAM, LPARAM)
1517 {
1518         Refresh();
1519         return 0;
1520 }
1521
1522 LRESULT CCommitDlg::OnFileDropped(WPARAM, LPARAM /*lParam*/)
1523 {
1524 #if 0
1525         BringWindowToTop();
1526         SetForegroundWindow();
1527         SetActiveWindow();
1528         // if multiple files/folders are dropped
1529         // this handler is called for every single item
1530         // separately.
1531         // To avoid creating multiple refresh threads and
1532         // causing crashes, we only add the items to the
1533         // list control and start a timer.
1534         // When the timer expires, we start the refresh thread,
1535         // but only if it isn't already running - otherwise we
1536         // restart the timer.
1537         CTGitPath path;
1538         path.SetFromWin((LPCTSTR)lParam);
1539
1540         // just add all the items we get here.
1541         // if the item is versioned, the add will fail but nothing
1542         // more will happen.
1543         Git Git;
1544         Git.Add(CTGitPathList(path), &m_ProjectProperties, Git_depth_empty, false, true, true);
1545
1546         if (!m_ListCtrl.HasPath(path))
1547         {
1548                 if (m_pathList.AreAllPathsFiles())
1549                 {
1550                         m_pathList.AddPath(path);
1551                         m_pathList.RemoveDuplicates();
1552                         m_updatedPathList.AddPath(path);
1553                         m_updatedPathList.RemoveDuplicates();
1554                 }
1555                 else
1556                 {
1557                         // if the path list contains folders, we have to check whether
1558                         // our just (maybe) added path is a child of one of those. If it is
1559                         // a child of a folder already in the list, we must not add it. Otherwise
1560                         // that path could show up twice in the list.
1561                         bool bHasParentInList = false;
1562                         for (int i=0; i<m_pathList.GetCount(); ++i)
1563                         {
1564                                 if (m_pathList[i].IsAncestorOf(path))
1565                                 {
1566                                         bHasParentInList = true;
1567                                         break;
1568                                 }
1569                         }
1570                         if (!bHasParentInList)
1571                         {
1572                                 m_pathList.AddPath(path);
1573                                 m_pathList.RemoveDuplicates();
1574                                 m_updatedPathList.AddPath(path);
1575                                 m_updatedPathList.RemoveDuplicates();
1576                         }
1577                 }
1578         }
1579
1580         // Always start the timer, since the status of an existing item might have changed
1581         SetTimer(REFRESHTIMER, 200, NULL);
1582         CTraceToOutputDebugString::Instance()(_T(__FUNCTION__) _T(": Item %s dropped, timer started\n"), path.GetWinPath());
1583 #endif
1584         return 0;
1585 }
1586
1587 LRESULT CCommitDlg::OnAutoListReady(WPARAM, LPARAM)
1588 {
1589         m_cLogMessage.SetAutoCompletionList(m_autolist, '*');
1590         return 0;
1591 }
1592
1593 //////////////////////////////////////////////////////////////////////////
1594 // functions which run in the status thread
1595 //////////////////////////////////////////////////////////////////////////
1596
1597 void CCommitDlg::ParseRegexFile(const CString& sFile, std::map<CString, CString>& mapRegex)
1598 {
1599         CString strLine;
1600         try
1601         {
1602                 CStdioFile file(sFile, CFile::typeText | CFile::modeRead | CFile::shareDenyWrite);
1603                 while (m_bRunThread && file.ReadString(strLine))
1604                 {
1605                         int eqpos = strLine.Find('=');
1606                         CString rgx;
1607                         rgx = strLine.Mid(eqpos+1).Trim();
1608
1609                         int pos = -1;
1610                         while (((pos = strLine.Find(','))>=0)&&(pos < eqpos))
1611                         {
1612                                 mapRegex[strLine.Left(pos)] = rgx;
1613                                 strLine = strLine.Mid(pos+1).Trim();
1614                         }
1615                         mapRegex[strLine.Left(strLine.Find('=')).Trim()] = rgx;
1616                 }
1617                 file.Close();
1618         }
1619         catch (CFileException* pE)
1620         {
1621                 CTraceToOutputDebugString::Instance()(__FUNCTION__ ": CFileException loading auto list regex file\n");
1622                 pE->Delete();
1623         }
1624 }
1625
1626 void CCommitDlg::GetAutocompletionList()
1627 {
1628         // the auto completion list is made of strings from each selected files.
1629         // the strings used are extracted from the files with regexes found
1630         // in the file "autolist.txt".
1631         // the format of that file is:
1632         // file extensions separated with commas '=' regular expression to use
1633         // example:
1634         // .h, .hpp = (?<=class[\s])\b\w+\b|(\b\w+(?=[\s ]?\(\);))
1635         // .cpp = (?<=[^\s]::)\b\w+\b
1636
1637         std::map<CString, CString> mapRegex;
1638         CString sRegexFile = CPathUtils::GetAppDirectory();
1639         CRegDWORD regtimeout = CRegDWORD(_T("Software\\TortoiseGit\\AutocompleteParseTimeout"), 5);
1640         DWORD timeoutvalue = regtimeout*1000;
1641         sRegexFile += _T("autolist.txt");
1642         if (!m_bRunThread)
1643                 return;
1644         ParseRegexFile(sRegexFile, mapRegex);
1645         SHGetFolderPath(NULL, CSIDL_APPDATA, NULL, SHGFP_TYPE_CURRENT, sRegexFile.GetBuffer(MAX_PATH+1));
1646         sRegexFile.ReleaseBuffer();
1647         sRegexFile += _T("\\TortoiseGit\\autolist.txt");
1648         if (PathFileExists(sRegexFile))
1649         {
1650                 ParseRegexFile(sRegexFile, mapRegex);
1651         }
1652         DWORD starttime = GetTickCount();
1653
1654         // now we have two arrays of strings, where the first array contains all
1655         // file extensions we can use and the second the corresponding regex strings
1656         // to apply to those files.
1657
1658         // the next step is to go over all files shown in the commit dialog
1659         // and scan them for strings we can use
1660         int nListItems = m_ListCtrl.GetItemCount();
1661
1662         for (int i=0; i<nListItems && m_bRunThread; ++i)
1663         {
1664                 // stop parsing after timeout
1665                 if ((!m_bRunThread) || (GetTickCount() - starttime > timeoutvalue))
1666                         return;
1667
1668                 CTGitPath *path = (CTGitPath*)m_ListCtrl.GetItemData(i);
1669
1670                 if(path == NULL)
1671                         continue;
1672
1673                 CString sPartPath =path->GetGitPathString();
1674                 m_autolist.insert(sPartPath);
1675
1676                 int pos = 0;
1677                 int lastPos = 0;
1678                 while ((pos = sPartPath.Find('/', pos)) >= 0)
1679                 {
1680                         ++pos;
1681                         lastPos = pos;
1682                         m_autolist.insert(sPartPath.Mid(pos));
1683                 }
1684
1685                 // Last inserted entry is a file name.
1686                 // Some users prefer to also list file name without extension.
1687                 if (CRegDWORD(_T("Software\\TortoiseGit\\AutocompleteRemovesExtensions"), FALSE))
1688                 {
1689                         int dotPos = sPartPath.ReverseFind('.');
1690                         if ((dotPos >= 0) && (dotPos > lastPos))
1691                                 m_autolist.insert(sPartPath.Mid(lastPos, dotPos - lastPos));
1692                 }
1693
1694                 if (path->m_Action == CTGitPath::LOGACTIONS_UNVER && !CRegDWORD(_T("Software\\TortoiseGit\\AutocompleteParseUnversioned"), FALSE))
1695                         continue;
1696                 if (path->m_Action == CTGitPath::LOGACTIONS_IGNORE || path->m_Action == CTGitPath::LOGACTIONS_DELETED)
1697                         continue;
1698
1699                 CString sExt = path->GetFileExtension();
1700                 sExt.MakeLower();
1701                 // find the regex string which corresponds to the file extension
1702                 CString rdata = mapRegex[sExt];
1703                 if (rdata.IsEmpty())
1704                         continue;
1705
1706                 ScanFile(path->GetWinPathString(), rdata, sExt);
1707         }
1708         CTraceToOutputDebugString::Instance()(_T(__FUNCTION__) _T(": Auto completion list loaded in %d msec\n"), GetTickCount() - starttime);
1709 }
1710
1711 void CCommitDlg::ScanFile(const CString& sFilePath, const CString& sRegex, const CString& sExt)
1712 {
1713         static std::map<CString, std::tr1::wregex> regexmap;
1714
1715         std::wstring sFileContent;
1716         CAutoFile hFile = CreateFile(sFilePath, GENERIC_READ, FILE_SHARE_READ, NULL, OPEN_EXISTING, NULL, NULL);
1717         if (hFile)
1718         {
1719                 DWORD size = GetFileSize(hFile, NULL);
1720                 if (size > CRegDWORD(_T("Software\\TortoiseGit\\AutocompleteParseMaxSize"), 300000L))
1721                 {
1722                         // no files bigger than 300k
1723                         return;
1724                 }
1725                 // allocate memory to hold file contents
1726                 std::unique_ptr<char[]> buffer(new char[size]);
1727                 DWORD readbytes;
1728                 if (!ReadFile(hFile, buffer.get(), size, &readbytes, NULL))
1729                         return;
1730                 int opts = 0;
1731                 IsTextUnicode(buffer.get(), readbytes, &opts);
1732                 if (opts & IS_TEXT_UNICODE_NULL_BYTES)
1733                 {
1734                         return;
1735                 }
1736                 if (opts & IS_TEXT_UNICODE_UNICODE_MASK)
1737                 {
1738                         sFileContent = std::wstring((wchar_t*)buffer.get(), readbytes / sizeof(WCHAR));
1739                 }
1740                 if ((opts & IS_TEXT_UNICODE_NOT_UNICODE_MASK) || (opts == 0))
1741                 {
1742                         const int ret = MultiByteToWideChar(CP_ACP, MB_PRECOMPOSED, (LPCSTR)buffer.get(), readbytes, NULL, 0);
1743                         std::unique_ptr<wchar_t[]> pWideBuf(new wchar_t[ret]);
1744                         const int ret2 = MultiByteToWideChar(CP_ACP, MB_PRECOMPOSED, (LPCSTR)buffer.get(), readbytes, pWideBuf.get(), ret);
1745                         if (ret2 == ret)
1746                                 sFileContent = std::wstring(pWideBuf.get(), ret);
1747                 }
1748         }
1749         if (sFileContent.empty() || !m_bRunThread)
1750         {
1751                 return;
1752         }
1753
1754         try
1755         {
1756
1757                 std::tr1::wregex regCheck;
1758                 std::map<CString, std::tr1::wregex>::const_iterator regIt;
1759                 if ((regIt = regexmap.find(sExt)) != regexmap.end())
1760                         regCheck = regIt->second;
1761                 else
1762                 {
1763                         regCheck = std::tr1::wregex(sRegex, std::tr1::regex_constants::icase | std::tr1::regex_constants::ECMAScript);
1764                         regexmap[sExt] = regCheck;
1765                 }
1766                 const std::tr1::wsregex_iterator end;
1767                 for (std::tr1::wsregex_iterator it(sFileContent.begin(), sFileContent.end(), regCheck); it != end; ++it)
1768                 {
1769                         const std::tr1::wsmatch match = *it;
1770                         for (size_t i = 1; i < match.size(); ++i)
1771                         {
1772                                 if (match[i].second-match[i].first)
1773                                 {
1774                                         m_autolist.insert(std::wstring(match[i]).c_str());
1775                                 }
1776                         }
1777                 }
1778         }
1779         catch (std::exception) {}
1780 }
1781
1782 // CSciEditContextMenuInterface
1783 void CCommitDlg::InsertMenuItems(CMenu& mPopup, int& nCmd)
1784 {
1785         CString sMenuItemText;
1786         sMenuItemText.LoadString(IDS_COMMITDLG_POPUP_PICKCOMMITHASH);
1787         m_nPopupPickCommitHash = nCmd++;
1788         mPopup.AppendMenu(MF_STRING | MF_ENABLED, m_nPopupPickCommitHash, sMenuItemText);
1789
1790         sMenuItemText.LoadString(IDS_COMMITDLG_POPUP_PICKCOMMITMESSAGE);
1791         m_nPopupPickCommitMessage = nCmd++;
1792         mPopup.AppendMenu(MF_STRING | MF_ENABLED, m_nPopupPickCommitMessage, sMenuItemText);
1793
1794         sMenuItemText.LoadString(IDS_COMMITDLG_POPUP_PASTEFILELIST);
1795         m_nPopupPasteListCmd = nCmd++;
1796         mPopup.AppendMenu(MF_STRING | MF_ENABLED, m_nPopupPasteListCmd, sMenuItemText);
1797
1798         if (m_History.GetCount() > 0)
1799         {
1800                 sMenuItemText.LoadString(IDS_COMMITDLG_POPUP_PASTELASTMESSAGE);
1801                 m_nPopupPasteLastMessage = nCmd++;
1802                 mPopup.AppendMenu(MF_STRING | MF_ENABLED, m_nPopupPasteLastMessage, sMenuItemText);
1803
1804                 sMenuItemText.LoadString(IDS_COMMITDLG_POPUP_LOGHISTORY);
1805                 m_nPopupRecentMessage = nCmd++;
1806                 mPopup.AppendMenu(MF_STRING | MF_ENABLED, m_nPopupRecentMessage, sMenuItemText);
1807         }
1808 }
1809
1810 bool CCommitDlg::HandleMenuItemClick(int cmd, CSciEdit * pSciEdit)
1811 {
1812         if (cmd == m_nPopupPickCommitHash)
1813         {
1814                 // use the git log to allow selection of a version
1815                 CLogDlg dlg;
1816                 // tell the dialog to use mode for selecting revisions
1817                 dlg.SetSelect(true);
1818                 // only one revision must be selected however
1819                 dlg.SingleSelection(true);
1820                 if (dlg.DoModal() == IDOK)
1821                 {
1822                         // get selected hash if any
1823                         CString selectedHash = dlg.GetSelectedHash();
1824                         pSciEdit->InsertText(selectedHash);
1825                 }
1826                 return true;
1827         }
1828
1829         if (cmd == m_nPopupPickCommitMessage)
1830         {
1831                 // use the git log to allow selection of a version
1832                 CLogDlg dlg;
1833                 // tell the dialog to use mode for selecting revisions
1834                 dlg.SetSelect(true);
1835                 // only one revision must be selected however
1836                 dlg.SingleSelection(true);
1837                 if (dlg.DoModal() == IDOK)
1838                 {
1839                         // get selected hash if any
1840                         CString selectedHash = dlg.GetSelectedHash();
1841                         GitRev rev;
1842                         rev.GetCommit(selectedHash);
1843                         CString message = rev.GetSubject() + _T("\r\n") + rev.GetBody();
1844                         pSciEdit->InsertText(message);
1845                 }
1846                 return true;
1847         }
1848
1849         if (cmd == m_nPopupPasteListCmd)
1850         {
1851                 CString logmsg;
1852                 int nListItems = m_ListCtrl.GetItemCount();
1853                 for (int i=0; i<nListItems; ++i)
1854                 {
1855                         CTGitPath * entry = (CTGitPath*)m_ListCtrl.GetItemData(i);
1856                         if (entry&&entry->m_Checked)
1857                         {
1858                                 CString line;
1859                                 CString status = entry->GetActionName();
1860                                 if(entry->m_Action & CTGitPath::LOGACTIONS_UNVER)
1861                                         status = _T("Add"); // I18N TODO
1862
1863                                 //git_wc_status_kind status = entry->status;
1864                                 WORD langID = (WORD)CRegStdDWORD(_T("Software\\TortoiseGit\\LanguageID"), GetUserDefaultLangID());
1865                                 if (m_ProjectProperties.bFileListInEnglish)
1866                                         langID = 1033;
1867
1868                                 line.Format(_T("%-10s %s\r\n"),status , (LPCTSTR)m_ListCtrl.GetItemText(i,0));
1869                                 logmsg += line;
1870                         }
1871                 }
1872                 pSciEdit->InsertText(logmsg);
1873                 return true;
1874         }
1875
1876         if(cmd == m_nPopupPasteLastMessage)
1877         {
1878                 if(m_History.GetCount() ==0 )
1879                         return false;
1880
1881                 CString logmsg;
1882                 logmsg +=m_History.GetEntry(0);
1883                 pSciEdit->InsertText(logmsg);
1884                 return true;
1885         }
1886
1887         if(cmd == m_nPopupRecentMessage )
1888         {
1889                 OnBnClickedHistory();
1890                 return true;
1891         }
1892         return false;
1893 }
1894
1895 void CCommitDlg::OnTimer(UINT_PTR nIDEvent)
1896 {
1897         switch (nIDEvent)
1898         {
1899         case ENDDIALOGTIMER:
1900                 KillTimer(ENDDIALOGTIMER);
1901                 EndDialog(0);
1902                 break;
1903         case REFRESHTIMER:
1904                 if (m_bThreadRunning)
1905                 {
1906                         SetTimer(REFRESHTIMER, 200, NULL);
1907                         CTraceToOutputDebugString::Instance()(__FUNCTION__ ": Wait some more before refreshing\n");
1908                 }
1909                 else
1910                 {
1911                         KillTimer(REFRESHTIMER);
1912                         CTraceToOutputDebugString::Instance()(__FUNCTION__ ": Refreshing after items dropped\n");
1913                         Refresh();
1914                 }
1915                 break;
1916         case FILLPATCHVTIMER:
1917                 FillPatchView();
1918                 break;
1919         }
1920         __super::OnTimer(nIDEvent);
1921 }
1922
1923 void CCommitDlg::OnBnClickedHistory()
1924 {
1925         m_tooltips.Pop();       // hide the tooltips
1926         if (m_pathList.GetCount() == 0)
1927                 return;
1928
1929         CHistoryDlg historyDlg;
1930         historyDlg.SetHistory(m_History);
1931         if (historyDlg.DoModal() != IDOK)
1932                 return;
1933
1934         CString sMsg = historyDlg.GetSelectedText();
1935         if (sMsg != m_cLogMessage.GetText().Left(sMsg.GetLength()))
1936         {
1937                 CString sBugID = m_ProjectProperties.FindBugID(sMsg);
1938                 if ((!sBugID.IsEmpty()) && ((GetDlgItem(IDC_BUGID)->IsWindowVisible())))
1939                 {
1940                         SetDlgItemText(IDC_BUGID, sBugID);
1941                 }
1942                 if (m_ProjectProperties.sLogTemplate.Compare(m_cLogMessage.GetText())!=0)
1943                         m_cLogMessage.InsertText(sMsg, !m_cLogMessage.GetText().IsEmpty());
1944                 else
1945                         m_cLogMessage.SetText(sMsg);
1946         }
1947
1948         SendMessage(WM_UPDATEOKBUTTON);
1949         GetDlgItem(IDC_LOGMESSAGE)->SetFocus();
1950
1951 }
1952
1953 void CCommitDlg::OnBnClickedBugtraqbutton()
1954 {
1955         m_tooltips.Pop();       // hide the tooltips
1956         CString sMsg = m_cLogMessage.GetText();
1957
1958         if (m_BugTraqProvider == NULL)
1959                 return;
1960
1961         BSTR parameters = m_bugtraq_association.GetParameters().AllocSysString();
1962         BSTR commonRoot = SysAllocString(g_Git.m_CurrentDir);
1963         SAFEARRAY *pathList = SafeArrayCreateVector(VT_BSTR, 0, m_pathList.GetCount());
1964
1965         for (LONG index = 0; index < m_pathList.GetCount(); ++index)
1966                 SafeArrayPutElement(pathList, &index, m_pathList[index].GetGitPathString().AllocSysString());
1967
1968         BSTR originalMessage = sMsg.AllocSysString();
1969         BSTR temp = NULL;
1970 //      m_revProps.clear();
1971
1972         // first try the IBugTraqProvider2 interface
1973         CComPtr<IBugTraqProvider2> pProvider2 = NULL;
1974         HRESULT hr = m_BugTraqProvider.QueryInterface(&pProvider2);
1975         bool bugIdOutSet = false;
1976         if (SUCCEEDED(hr))
1977         {
1978                 //CString common = m_ListCtrl.GetCommonURL(false).GetGitPathString();
1979                 BSTR repositoryRoot = g_Git.m_CurrentDir.AllocSysString();
1980                 BSTR bugIDOut = NULL;
1981                 GetDlgItemText(IDC_BUGID, m_sBugID);
1982                 BSTR bugID = m_sBugID.AllocSysString();
1983                 SAFEARRAY * revPropNames = NULL;
1984                 SAFEARRAY * revPropValues = NULL;
1985                 if (FAILED(hr = pProvider2->GetCommitMessage2(GetSafeHwnd(), parameters, repositoryRoot, commonRoot, pathList, originalMessage, bugID, &bugIDOut, &revPropNames, &revPropValues, &temp)))
1986                 {
1987                         CString sErr;
1988                         sErr.Format(IDS_ERR_FAILEDISSUETRACKERCOM, m_bugtraq_association.GetProviderName(), _com_error(hr).ErrorMessage());
1989                         CMessageBox::Show(m_hWnd, sErr, _T("TortoiseGit"), MB_ICONERROR);
1990                 }
1991                 else
1992                 {
1993                         if (bugIDOut)
1994                         {
1995                                 bugIdOutSet = true;
1996                                 m_sBugID = bugIDOut;
1997                                 SysFreeString(bugIDOut);
1998                                 SetDlgItemText(IDC_BUGID, m_sBugID);
1999                         }
2000                         SysFreeString(bugID);
2001                         SysFreeString(repositoryRoot);
2002                         m_cLogMessage.SetText(temp);
2003                         BSTR HUGEP *pbRevNames;
2004                         BSTR HUGEP *pbRevValues;
2005
2006                         HRESULT hr1 = SafeArrayAccessData(revPropNames, (void HUGEP**)&pbRevNames);
2007                         if (SUCCEEDED(hr1))
2008                         {
2009                                 HRESULT hr2 = SafeArrayAccessData(revPropValues, (void HUGEP**)&pbRevValues);
2010                                 if (SUCCEEDED(hr2))
2011                                 {
2012                                         if (revPropNames->rgsabound->cElements == revPropValues->rgsabound->cElements)
2013                                         {
2014                                                 for (ULONG i = 0; i < revPropNames->rgsabound->cElements; ++i)
2015                                                 {
2016 //                                                      m_revProps[pbRevNames[i]] = pbRevValues[i];
2017                                                 }
2018                                         }
2019                                         SafeArrayUnaccessData(revPropValues);
2020                                 }
2021                                 SafeArrayUnaccessData(revPropNames);
2022                         }
2023                         if (revPropNames)
2024                                 SafeArrayDestroy(revPropNames);
2025                         if (revPropValues)
2026                                 SafeArrayDestroy(revPropValues);
2027                 }
2028         }
2029         else
2030         {
2031                 // if IBugTraqProvider2 failed, try IBugTraqProvider
2032                 CComPtr<IBugTraqProvider> pProvider = NULL;
2033                 hr = m_BugTraqProvider.QueryInterface(&pProvider);
2034                 if (FAILED(hr))
2035                 {
2036                         CString sErr;
2037                         sErr.Format(IDS_ERR_FAILEDISSUETRACKERCOM, (LPCTSTR)m_bugtraq_association.GetProviderName(), _com_error(hr).ErrorMessage());
2038                         CMessageBox::Show(m_hWnd, sErr, _T("TortoiseGit"), MB_ICONERROR);
2039                         SysFreeString(parameters);
2040                         SysFreeString(commonRoot);
2041                         SafeArrayDestroy(pathList);
2042                         SysFreeString(originalMessage);
2043                         return;
2044                 }
2045
2046                 if (FAILED(hr = pProvider->GetCommitMessage(GetSafeHwnd(), parameters, commonRoot, pathList, originalMessage, &temp)))
2047                 {
2048                         CString sErr;
2049                         sErr.Format(IDS_ERR_FAILEDISSUETRACKERCOM, m_bugtraq_association.GetProviderName(), _com_error(hr).ErrorMessage());
2050                         CMessageBox::Show(m_hWnd, sErr, _T("TortoiseGit"), MB_ICONERROR);
2051                 }
2052                 else
2053                         m_cLogMessage.SetText(temp);
2054         }
2055         m_sLogMessage = m_cLogMessage.GetText();
2056         if (!m_ProjectProperties.sMessage.IsEmpty())
2057         {
2058                 CString sBugID = m_ProjectProperties.FindBugID(m_sLogMessage);
2059                 if (!sBugID.IsEmpty() && !bugIdOutSet)
2060                 {
2061                         SetDlgItemText(IDC_BUGID, sBugID);
2062                 }
2063         }
2064
2065         m_cLogMessage.SetFocus();
2066
2067         SysFreeString(parameters);
2068         SysFreeString(commonRoot);
2069         SafeArrayDestroy(pathList);
2070         SysFreeString(originalMessage);
2071         SysFreeString(temp);
2072 }
2073
2074 void CCommitDlg::FillPatchView(bool onlySetTimer)
2075 {
2076         if(::IsWindow(this->m_patchViewdlg.m_hWnd))
2077         {
2078                 KillTimer(FILLPATCHVTIMER);
2079                 if (onlySetTimer)
2080                 {
2081                         SetTimer(FILLPATCHVTIMER, 100, NULL);
2082                         return;
2083                 }
2084                 m_patchViewdlg.m_ctrlPatchView.SetText(CString());
2085
2086                 POSITION pos=m_ListCtrl.GetFirstSelectedItemPosition();
2087                 m_patchViewdlg.m_ctrlPatchView.Call(SCI_SETREADONLY, FALSE);
2088                 CString cmd,out;
2089
2090                 while(pos)
2091                 {
2092                         int nSelect = m_ListCtrl.GetNextSelectedItem(pos);
2093                         CTGitPath * p=(CTGitPath*)m_ListCtrl.GetItemData(nSelect);
2094                         if(p && !(p->m_Action&CTGitPath::LOGACTIONS_UNVER) )
2095                         {
2096                                 CString head = _T("HEAD");
2097                                 if(m_bCommitAmend==TRUE && m_bAmendDiffToLastCommit==FALSE)
2098                                         head = _T("HEAD~1");
2099                                 cmd.Format(_T("git.exe diff %s -- \"%s\""), head, p->GetGitPathString());
2100                                 g_Git.Run(cmd, &out, CP_UTF8);
2101                         }
2102                 }
2103
2104                 m_patchViewdlg.m_ctrlPatchView.SetText(out);
2105                 m_patchViewdlg.m_ctrlPatchView.Call(SCI_SETREADONLY, TRUE);
2106                 m_patchViewdlg.m_ctrlPatchView.Call(SCI_GOTOPOS, 0);
2107                 CRect rect;
2108                 m_patchViewdlg.m_ctrlPatchView.GetClientRect(rect);
2109                 m_patchViewdlg.m_ctrlPatchView.Call(SCI_SETSCROLLWIDTH, rect.Width() - 4);
2110         }
2111 }
2112 LRESULT CCommitDlg::OnGitStatusListCtrlItemChanged(WPARAM /*wparam*/, LPARAM /*lparam*/)
2113 {
2114         this->FillPatchView(true);
2115         return 0;
2116 }
2117
2118
2119 LRESULT CCommitDlg::OnGitStatusListCtrlCheckChanged(WPARAM, LPARAM)
2120 {
2121         SendMessage(WM_UPDATEOKBUTTON);
2122         return 0;
2123 }
2124
2125 LRESULT CCommitDlg::OnCheck(WPARAM wnd, LPARAM)
2126 {
2127         HWND hwnd = (HWND)wnd;
2128         bool check = !(GetAsyncKeyState(VK_SHIFT) & 0x8000);
2129         if (hwnd == GetDlgItem(IDC_CHECKALL)->GetSafeHwnd())
2130                 m_ListCtrl.Check(GITSLC_SHOWEVERYTHING, check);
2131         else if (hwnd == GetDlgItem(IDC_CHECKNONE)->GetSafeHwnd())
2132                 m_ListCtrl.Check(GITSLC_SHOWEVERYTHING, !check);
2133         else if (hwnd == GetDlgItem(IDC_CHECKUNVERSIONED)->GetSafeHwnd())
2134                 m_ListCtrl.Check(GITSLC_SHOWUNVERSIONED, check);
2135         else if (hwnd == GetDlgItem(IDC_CHECKVERSIONED)->GetSafeHwnd())
2136                 m_ListCtrl.Check(GITSLC_SHOWVERSIONED, check);
2137         else if (hwnd == GetDlgItem(IDC_CHECKADDED)->GetSafeHwnd())
2138                 m_ListCtrl.Check(GITSLC_SHOWADDED, check);
2139         else if (hwnd == GetDlgItem(IDC_CHECKDELETED)->GetSafeHwnd())
2140                 m_ListCtrl.Check(GITSLC_SHOWREMOVED, check);
2141         else if (hwnd == GetDlgItem(IDC_CHECKMODIFIED)->GetSafeHwnd())
2142                 m_ListCtrl.Check(GITSLC_SHOWMODIFIED, check);
2143         else if (hwnd == GetDlgItem(IDC_CHECKFILES)->GetSafeHwnd())
2144                 m_ListCtrl.Check(GITSLC_SHOWFILES, check);
2145         else if (hwnd == GetDlgItem(IDC_CHECKSUBMODULES)->GetSafeHwnd())
2146                 m_ListCtrl.Check(GITSLC_SHOWSUBMODULES, check);
2147
2148         return 0;
2149 }
2150
2151 LRESULT CCommitDlg::OnUpdateOKButton(WPARAM, LPARAM)
2152 {
2153         if (m_bBlock)
2154                 return 0;
2155
2156         bool bValidLogSize = m_cLogMessage.GetText().GetLength() >= m_ProjectProperties.nMinLogSize && m_cLogMessage.GetText().GetLength() > 0;
2157         bool bAmendOrSelectFilesOrMerge = m_ListCtrl.GetSelected() > 0 || (m_bCommitAmend && m_bAmendDiffToLastCommit) || CTGitPath(g_Git.m_CurrentDir).IsMergeActive();
2158
2159         DialogEnableWindow(IDOK, bValidLogSize && (m_bCommitMessageOnly || bAmendOrSelectFilesOrMerge));
2160
2161         return 0;
2162 }
2163
2164 LRESULT CCommitDlg::OnUpdateDataFalse(WPARAM, LPARAM)
2165 {
2166         UpdateData(FALSE);
2167         return 0;
2168 }
2169
2170 LRESULT CCommitDlg::DefWindowProc(UINT message, WPARAM wParam, LPARAM lParam)
2171 {
2172         switch (message) {
2173         case WM_NOTIFY:
2174                 if (wParam == IDC_SPLITTER)
2175                 {
2176                         SPC_NMHDR* pHdr = (SPC_NMHDR*) lParam;
2177                         DoSize(pHdr->delta);
2178                 }
2179                 break;
2180         }
2181
2182         return __super::DefWindowProc(message, wParam, lParam);
2183 }
2184
2185 void CCommitDlg::SetSplitterRange()
2186 {
2187         if ((m_ListCtrl)&&(m_cLogMessage))
2188         {
2189                 CRect rcTop;
2190                 m_cLogMessage.GetWindowRect(rcTop);
2191                 ScreenToClient(rcTop);
2192                 CRect rcMiddle;
2193                 m_ListCtrl.GetWindowRect(rcMiddle);
2194                 ScreenToClient(rcMiddle);
2195                 if (rcMiddle.Height() && rcMiddle.Width())
2196                         m_wndSplitter.SetRange(rcTop.top + 100, rcMiddle.bottom - 80);
2197         }
2198 }
2199
2200 void CCommitDlg::DoSize(int delta)
2201 {
2202         RemoveAnchor(IDC_MESSAGEGROUP);
2203         RemoveAnchor(IDC_LOGMESSAGE);
2204         RemoveAnchor(IDC_SPLITTER);
2205         RemoveAnchor(IDC_SIGNOFF);
2206         RemoveAnchor(IDC_COMMIT_AMEND);
2207         RemoveAnchor(IDC_COMMIT_AMENDDIFF);
2208         RemoveAnchor(IDC_COMMIT_SETDATETIME);
2209         RemoveAnchor(IDC_COMMIT_DATEPICKER);
2210         RemoveAnchor(IDC_COMMIT_TIMEPICKER);
2211         RemoveAnchor(IDC_COMMIT_SETAUTHOR);
2212         RemoveAnchor(IDC_COMMIT_AUTHORDATA);
2213         RemoveAnchor(IDC_LISTGROUP);
2214         RemoveAnchor(IDC_FILELIST);
2215         RemoveAnchor(IDC_TEXT_INFO);
2216         RemoveAnchor(IDC_SELECTLABEL);
2217         RemoveAnchor(IDC_CHECKALL);
2218         RemoveAnchor(IDC_CHECKNONE);
2219         RemoveAnchor(IDC_CHECKUNVERSIONED);
2220         RemoveAnchor(IDC_CHECKVERSIONED);
2221         RemoveAnchor(IDC_CHECKADDED);
2222         RemoveAnchor(IDC_CHECKDELETED);
2223         RemoveAnchor(IDC_CHECKMODIFIED);
2224         RemoveAnchor(IDC_CHECKFILES);
2225         RemoveAnchor(IDC_CHECKSUBMODULES);
2226
2227         CSplitterControl::ChangeHeight(&m_cLogMessage, delta, CW_TOPALIGN);
2228         CSplitterControl::ChangeHeight(GetDlgItem(IDC_MESSAGEGROUP), delta, CW_TOPALIGN);
2229         CSplitterControl::ChangeHeight(&m_ListCtrl, -delta, CW_BOTTOMALIGN);
2230         CSplitterControl::ChangeHeight(GetDlgItem(IDC_LISTGROUP), -delta, CW_BOTTOMALIGN);
2231         CSplitterControl::ChangePos(GetDlgItem(IDC_SIGNOFF),0,delta);
2232         CSplitterControl::ChangePos(GetDlgItem(IDC_COMMIT_AMEND),0,delta);
2233         CSplitterControl::ChangePos(GetDlgItem(IDC_COMMIT_AMENDDIFF),0,delta);
2234         CSplitterControl::ChangePos(GetDlgItem(IDC_COMMIT_SETDATETIME),0,delta);
2235         CSplitterControl::ChangePos(GetDlgItem(IDC_COMMIT_DATEPICKER),0,delta);
2236         CSplitterControl::ChangePos(GetDlgItem(IDC_COMMIT_TIMEPICKER),0,delta);
2237         CSplitterControl::ChangePos(GetDlgItem(IDC_COMMIT_SETAUTHOR), 0, delta);
2238         CSplitterControl::ChangePos(GetDlgItem(IDC_COMMIT_AUTHORDATA), 0, delta);
2239         CSplitterControl::ChangePos(GetDlgItem(IDC_TEXT_INFO),0,delta);
2240         CSplitterControl::ChangePos(GetDlgItem(IDC_SELECTLABEL), 0, delta);
2241         CSplitterControl::ChangePos(GetDlgItem(IDC_CHECKALL), 0, delta);
2242         CSplitterControl::ChangePos(GetDlgItem(IDC_CHECKNONE), 0, delta);
2243         CSplitterControl::ChangePos(GetDlgItem(IDC_CHECKUNVERSIONED), 0, delta);
2244         CSplitterControl::ChangePos(GetDlgItem(IDC_CHECKVERSIONED), 0, delta);
2245         CSplitterControl::ChangePos(GetDlgItem(IDC_CHECKADDED), 0, delta);
2246         CSplitterControl::ChangePos(GetDlgItem(IDC_CHECKDELETED), 0, delta);
2247         CSplitterControl::ChangePos(GetDlgItem(IDC_CHECKMODIFIED), 0, delta);
2248         CSplitterControl::ChangePos(GetDlgItem(IDC_CHECKFILES), 0, delta);
2249         CSplitterControl::ChangePos(GetDlgItem(IDC_CHECKSUBMODULES), 0, delta);
2250
2251         AddAnchor(IDC_MESSAGEGROUP, TOP_LEFT, TOP_RIGHT);
2252         AddAnchor(IDC_LOGMESSAGE, TOP_LEFT, TOP_RIGHT);
2253         AddAnchor(IDC_SPLITTER, TOP_LEFT, TOP_RIGHT);
2254         AddAnchor(IDC_LISTGROUP, TOP_LEFT, BOTTOM_RIGHT);
2255         AddAnchor(IDC_FILELIST, TOP_LEFT, BOTTOM_RIGHT);
2256         AddAnchor(IDC_SIGNOFF,TOP_RIGHT);
2257         AddAnchor(IDC_COMMIT_AMEND,TOP_LEFT);
2258         AddAnchor(IDC_COMMIT_AMENDDIFF,TOP_LEFT);
2259         AddAnchor(IDC_COMMIT_SETDATETIME,TOP_LEFT);
2260         AddAnchor(IDC_COMMIT_DATEPICKER,TOP_LEFT);
2261         AddAnchor(IDC_COMMIT_TIMEPICKER,TOP_LEFT);
2262         AddAnchor(IDC_COMMIT_SETAUTHOR, TOP_LEFT);
2263         AddAnchor(IDC_COMMIT_AUTHORDATA, TOP_LEFT, TOP_RIGHT);
2264         AddAnchor(IDC_TEXT_INFO,TOP_RIGHT);
2265         AddAnchor(IDC_SELECTLABEL, TOP_LEFT);
2266         AddAnchor(IDC_CHECKALL, TOP_LEFT);
2267         AddAnchor(IDC_CHECKNONE, TOP_LEFT);
2268         AddAnchor(IDC_CHECKUNVERSIONED, TOP_LEFT);
2269         AddAnchor(IDC_CHECKVERSIONED, TOP_LEFT);
2270         AddAnchor(IDC_CHECKADDED, TOP_LEFT);
2271         AddAnchor(IDC_CHECKDELETED, TOP_LEFT);
2272         AddAnchor(IDC_CHECKMODIFIED, TOP_LEFT);
2273         AddAnchor(IDC_CHECKFILES, TOP_LEFT);
2274         AddAnchor(IDC_CHECKSUBMODULES, TOP_LEFT);
2275         ArrangeLayout();
2276         // adjust the minimum size of the dialog to prevent the resizing from
2277         // moving the list control too far down.
2278         CRect rcLogMsg;
2279         m_cLogMessage.GetClientRect(rcLogMsg);
2280         SetMinTrackSize(CSize(m_DlgOrigRect.Width(), m_DlgOrigRect.Height()-m_LogMsgOrigRect.Height()+rcLogMsg.Height()));
2281
2282         SetSplitterRange();
2283         m_cLogMessage.Invalidate();
2284         GetDlgItem(IDC_LOGMESSAGE)->Invalidate();
2285 }
2286
2287 void CCommitDlg::OnSize(UINT nType, int cx, int cy)
2288 {
2289         // first, let the resizing take place
2290         __super::OnSize(nType, cx, cy);
2291
2292         //set range
2293         SetSplitterRange();
2294 }
2295
2296 CString CCommitDlg::GetSignedOffByLine()
2297 {
2298         CString str;
2299
2300         CString username = g_Git.GetUserName();
2301         CString email = g_Git.GetUserEmail();
2302         username.Remove(_T('\n'));
2303         email.Remove(_T('\n'));
2304
2305         str.Format(_T("Signed-off-by: %s <%s>"), username, email);
2306
2307         return str;
2308 }
2309
2310 void CCommitDlg::OnBnClickedSignOff()
2311 {
2312         CString str = GetSignedOffByLine();
2313
2314         if (m_cLogMessage.GetText().Find(str) == -1) {
2315                 m_cLogMessage.SetText(m_cLogMessage.GetText().TrimRight());
2316                 int lastNewline = m_cLogMessage.GetText().ReverseFind(_T('\n'));
2317                 int foundByLine = -1;
2318                 if (lastNewline > 0)
2319                         foundByLine = m_cLogMessage.GetText().Find(_T("-by: "), lastNewline);
2320
2321                 if (foundByLine == -1 || foundByLine < lastNewline)
2322                         str = _T("\r\n") + str;
2323
2324                 m_cLogMessage.SetText(m_cLogMessage.GetText()+_T("\r\n")+str+_T("\r\n"));
2325         }
2326 }
2327
2328 void CCommitDlg::OnBnClickedCommitAmend()
2329 {
2330         this->UpdateData();
2331         if(this->m_bCommitAmend && this->m_AmendStr.IsEmpty())
2332         {
2333                 GitRev rev;
2334                 try
2335                 {
2336                         rev.GetCommit(CString(_T("HEAD")));
2337                 }
2338                 catch (const char *msg)
2339                 {
2340                         CMessageBox::Show(m_hWnd, _T("Could not get HEAD commit.\nlibgit reports:\n") + CString(msg), _T("TortoiseGit"), MB_ICONERROR);
2341                 }
2342                 m_AmendStr=rev.GetSubject()+_T("\n")+rev.GetBody();
2343         }
2344
2345         if(this->m_bCommitAmend)
2346         {
2347                 this->m_NoAmendStr=this->m_cLogMessage.GetText();
2348                 m_cLogMessage.SetText(m_AmendStr);
2349                 GetDlgItem(IDC_COMMIT_AMENDDIFF)->ShowWindow(SW_SHOW);
2350         }
2351         else
2352         {
2353                 this->m_AmendStr=this->m_cLogMessage.GetText();
2354                 m_cLogMessage.SetText(m_NoAmendStr);
2355                 GetDlgItem(IDC_COMMIT_AMENDDIFF)->ShowWindow(SW_HIDE);
2356         }
2357
2358         OnBnClickedCommitSetDateTime(); // to update the commit date and time
2359         OnBnClickedCommitSetauthor(); // to update the commit author
2360
2361         GetDlgItem(IDC_LOGMESSAGE)->SetFocus();
2362         Refresh();
2363 }
2364
2365 void CCommitDlg::OnBnClickedCommitMessageOnly()
2366 {
2367         this->UpdateData();
2368         this->m_ListCtrl.EnableWindow(m_bCommitMessageOnly ? FALSE : TRUE);
2369         SendMessage(WM_UPDATEOKBUTTON);
2370 }
2371
2372 void CCommitDlg::OnBnClickedWholeProject()
2373 {
2374         m_tooltips.Pop();       // hide the tooltips
2375         UpdateData();
2376         m_ListCtrl.Clear();
2377         if (!m_bBlock)
2378         {
2379                 if(m_bWholeProject)
2380                         m_ListCtrl.GetStatus(NULL,true,false,true);
2381                 else
2382                         m_ListCtrl.GetStatus(&this->m_pathList,true,false,true);
2383
2384                 DWORD dwShow = m_ListCtrl.GetShowFlags();
2385                 if (DWORD(m_regAddBeforeCommit))
2386                         dwShow |= GITSLC_SHOWUNVERSIONED;
2387                 else
2388                         dwShow &= ~GITSLC_SHOWUNVERSIONED;
2389
2390                 m_ListCtrl.Show(dwShow, dwShow & ~(CTGitPath::LOGACTIONS_UNVER), true);
2391                 UpdateCheckLinks();
2392         }
2393
2394         SetDlgTitle();
2395 }
2396
2397 void CCommitDlg::OnFocusMessage()
2398 {
2399         m_cLogMessage.SetFocus();
2400 }
2401
2402 void CCommitDlg::OnFocusFileList()
2403 {
2404         m_ListCtrl.SetFocus();
2405 }
2406
2407 void CCommitDlg::OnScnUpdateUI(NMHDR * /*pNMHDR*/, LRESULT *pResult)
2408 {
2409         int pos = (int)this->m_cLogMessage.Call(SCI_GETCURRENTPOS);
2410         int line = (int)this->m_cLogMessage.Call(SCI_LINEFROMPOSITION,pos);
2411         int column = (int)this->m_cLogMessage.Call(SCI_GETCOLUMN,pos);
2412
2413         CString str;
2414         str.Format(_T("%d/%d"),line+1,column+1);
2415         this->GetDlgItem(IDC_TEXT_INFO)->SetWindowText(str);
2416
2417         if(*pResult)
2418                 *pResult=0;
2419 }
2420 void CCommitDlg::OnStnClickedViewPatch()
2421 {
2422         m_patchViewdlg.m_pProjectProperties = &this->m_ProjectProperties;
2423         m_patchViewdlg.m_ParentCommitDlg = this;
2424         if(!IsWindow(this->m_patchViewdlg.m_hWnd))
2425         {
2426                 BOOL viewPatchEnabled = FALSE;
2427                 viewPatchEnabled = g_Git.GetConfigValueBool(_T("tgit.commitshowpatch"));
2428                 if (viewPatchEnabled == FALSE)
2429                         g_Git.SetConfigValue(_T("tgit.commitshowpatch"), _T("true"));
2430                 m_patchViewdlg.Create(IDD_PATCH_VIEW,this);
2431                 m_patchViewdlg.m_ctrlPatchView.Call(SCI_SETSCROLLWIDTHTRACKING, TRUE);
2432                 CRect rect;
2433                 this->GetWindowRect(&rect);
2434
2435                 m_patchViewdlg.ShowWindow(SW_SHOW);
2436
2437                 m_patchViewdlg.SetWindowPos(NULL,rect.right,rect.top,rect.Width(),rect.Height(),
2438                                 SWP_NOACTIVATE | SWP_NOOWNERZORDER | SWP_NOZORDER);
2439
2440                 ShowViewPatchText(false);
2441                 FillPatchView();
2442         }
2443         else
2444         {
2445                 g_Git.SetConfigValue(_T("tgit.commitshowpatch"), _T("false"));
2446                 m_patchViewdlg.ShowWindow(SW_HIDE);
2447                 m_patchViewdlg.DestroyWindow();
2448                 ShowViewPatchText(true);
2449         }
2450         this->m_ctrlShowPatch.Invalidate();
2451 }
2452
2453 void CCommitDlg::OnMoving(UINT fwSide, LPRECT pRect)
2454 {
2455         __super::OnMoving(fwSide, pRect);
2456
2457         if (::IsWindow(m_patchViewdlg.m_hWnd))
2458         {
2459                 RECT patchrect;
2460                 m_patchViewdlg.GetWindowRect(&patchrect);
2461                 if (::IsWindow(m_hWnd))
2462                 {
2463                         RECT thisrect;
2464                         GetWindowRect(&thisrect);
2465                         if (patchrect.left == thisrect.right)
2466                         {
2467                                 m_patchViewdlg.SetWindowPos(NULL, patchrect.left - (thisrect.left - pRect->left), patchrect.top - (thisrect.top - pRect->top),
2468                                         0, 0, SWP_NOACTIVATE | SWP_NOOWNERZORDER | SWP_NOSIZE | SWP_NOZORDER);
2469                         }
2470                 }
2471         }
2472
2473 }
2474
2475 void CCommitDlg::OnSizing(UINT fwSide, LPRECT pRect)
2476 {
2477         __super::OnSizing(fwSide, pRect);
2478
2479         if(::IsWindow(this->m_patchViewdlg.m_hWnd))
2480         {
2481                 CRect thisrect, patchrect;
2482                 this->GetWindowRect(thisrect);
2483                 this->m_patchViewdlg.GetWindowRect(patchrect);
2484                 if(thisrect.right==patchrect.left)
2485                 {
2486                         patchrect.left -= (thisrect.right - pRect->right);
2487                         patchrect.right-= (thisrect.right - pRect->right);
2488
2489                         if(     patchrect.bottom == thisrect.bottom)
2490                         {
2491                                 patchrect.bottom -= (thisrect.bottom - pRect->bottom);
2492                         }
2493                         if(     patchrect.top == thisrect.top)
2494                         {
2495                                 patchrect.top -=  thisrect.top-pRect->top;
2496                         }
2497                         m_patchViewdlg.MoveWindow(patchrect);
2498                 }
2499         }
2500 }
2501
2502 void CCommitDlg::OnHdnItemchangedFilelist(NMHDR * /*pNMHDR*/, LRESULT *pResult)
2503 {
2504         *pResult = 0;
2505         TRACE("Item Changed\r\n");
2506 }
2507
2508 int CCommitDlg::CheckHeadDetach()
2509 {
2510         CString output;
2511         if(g_Git.GetCurrentBranchFromFile(g_Git.m_CurrentDir,output))
2512         {
2513                 int retval = CMessageBox::Show(NULL, IDS_PROC_COMMIT_DETACHEDWARNING, IDS_APPNAME, MB_YESNOCANCEL | MB_ICONWARNING);
2514                 if(retval == IDYES)
2515                 {
2516                         if (CAppUtils::CreateBranchTag(FALSE, NULL, true) == FALSE)
2517                                 return 1;
2518                 }
2519                 else if (retval == IDCANCEL)
2520                         return 1;
2521         }
2522         return 0;
2523 }
2524
2525 void CCommitDlg::OnBnClickedCommitAmenddiff()
2526 {
2527         UpdateData();
2528         Refresh();
2529 }
2530
2531 void CCommitDlg::OnBnClickedNoautoselectsubmodules()
2532 {
2533         UpdateData();
2534         Refresh();
2535 }
2536
2537 void CCommitDlg::OnBnClickedCommitSetDateTime()
2538 {
2539         UpdateData();
2540
2541         if (m_bSetCommitDateTime)
2542         {
2543                 CTime authordate = CTime::GetCurrentTime();
2544                 if (m_bCommitAmend)
2545                 {
2546                         GitRev headRevision;
2547                         try
2548                         {
2549                                 headRevision.GetCommit(_T("HEAD"));
2550                         }
2551                         catch (const char *msg)
2552                         {
2553                                 CMessageBox::Show(m_hWnd, _T("Could not get HEAD commit.\nlibgit reports:\n") + CString(msg), _T("TortoiseGit"), MB_ICONERROR);
2554                         }
2555                         authordate = headRevision.GetAuthorDate();
2556                 }
2557
2558                 m_CommitDate.SetTime(&authordate);
2559                 m_CommitTime.SetTime(&authordate);
2560
2561                 GetDlgItem(IDC_COMMIT_DATEPICKER)->ShowWindow(SW_SHOW);
2562                 GetDlgItem(IDC_COMMIT_TIMEPICKER)->ShowWindow(SW_SHOW);
2563         }
2564         else
2565         {
2566                 GetDlgItem(IDC_COMMIT_DATEPICKER)->ShowWindow(SW_HIDE);
2567                 GetDlgItem(IDC_COMMIT_TIMEPICKER)->ShowWindow(SW_HIDE);
2568         }
2569 }
2570
2571 void CCommitDlg::OnBnClickedCheckNewBranch()
2572 {
2573         UpdateData();
2574         if (m_bCreateNewBranch)
2575         {
2576                 GetDlgItem(IDC_COMMIT_TO)->ShowWindow(SW_HIDE);
2577                 GetDlgItem(IDC_NEWBRANCH)->ShowWindow(SW_SHOW);
2578         }
2579         else
2580         {
2581                 GetDlgItem(IDC_NEWBRANCH)->ShowWindow(SW_HIDE);
2582                 GetDlgItem(IDC_COMMIT_TO)->ShowWindow(SW_SHOW);
2583         }
2584 }
2585
2586 void CCommitDlg::RestoreFiles(bool doNotAsk)
2587 {
2588         if (!m_ListCtrl.m_restorepaths.empty() && (doNotAsk || CMessageBox::Show(m_hWnd, IDS_PROC_COMMIT_RESTOREFILES, IDS_APPNAME, 2, IDI_QUESTION, IDS_PROC_COMMIT_RESTOREFILES_RESTORE, IDS_PROC_COMMIT_RESTOREFILES_KEEP) == 1))
2589         {
2590                 for (std::map<CString, CString>::iterator it = m_ListCtrl.m_restorepaths.begin(); it != m_ListCtrl.m_restorepaths.end(); ++it)
2591                         CopyFile(it->second, g_Git.m_CurrentDir + _T("\\") + it->first, FALSE);
2592                 m_ListCtrl.m_restorepaths.clear();
2593         }
2594 }
2595
2596 void CCommitDlg::UpdateCheckLinks()
2597 {
2598         DialogEnableWindow(IDC_CHECKALL, true);
2599         DialogEnableWindow(IDC_CHECKNONE, true);
2600         DialogEnableWindow(IDC_CHECKUNVERSIONED, m_ListCtrl.GetUnversionedCount() > 0);
2601         DialogEnableWindow(IDC_CHECKVERSIONED, m_ListCtrl.GetItemCount() > m_ListCtrl.GetUnversionedCount());
2602         DialogEnableWindow(IDC_CHECKADDED, m_ListCtrl.GetAddedCount() > 0);
2603         DialogEnableWindow(IDC_CHECKDELETED, m_ListCtrl.GetDeletedCount() > 0);
2604         DialogEnableWindow(IDC_CHECKMODIFIED, m_ListCtrl.GetModifiedCount() > 0);
2605         DialogEnableWindow(IDC_CHECKFILES, m_ListCtrl.GetFileCount() > 0);
2606         DialogEnableWindow(IDC_CHECKSUBMODULES, m_ListCtrl.GetSubmoduleCount() > 0);
2607 }
2608
2609 void CCommitDlg::OnBnClickedCommitSetauthor()
2610 {
2611         UpdateData();
2612
2613         if (m_bSetAuthor)
2614         {
2615                 m_sAuthor.Format(_T("%s <%s>"), g_Git.GetUserName(), g_Git.GetUserEmail());
2616                 if (m_bCommitAmend)
2617                 {
2618                         GitRev headRevision;
2619                         try
2620                         {
2621                                 headRevision.GetCommit(_T("HEAD"));
2622                         }
2623                         catch (const char *msg)
2624                         {
2625                                 CMessageBox::Show(m_hWnd, _T("Could not get HEAD commit.\nlibgit reports:\n") + CString(msg), _T("TortoiseGit"), MB_ICONERROR);
2626                         }
2627                         m_sAuthor.Format(_T("%s <%s>"), headRevision.GetAuthorName(), headRevision.GetAuthorEmail());
2628                 }
2629
2630                 UpdateData(FALSE);
2631
2632                 GetDlgItem(IDC_COMMIT_AUTHORDATA)->ShowWindow(SW_SHOW);
2633         }
2634         else
2635                 GetDlgItem(IDC_COMMIT_AUTHORDATA)->ShowWindow(SW_HIDE);
2636 }