src/TortoiseProc/CommitDlg.cpp

   1 // TortoiseGit - a Windows shell extension for easy version control
   2
   3 // Copyright (C) 2003-2008 - TortoiseSVN
   4 // Copyright (C) 2008-2012 - 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 "GitConfig.h"
  25 #include "ProjectProperties.h"
  26 #include "MessageBox.h"
  27 #include "AppUtils.h"
  28 #include "PathUtils.h"
  29 #include "Git.h"
  30 #include "Registry.h"
  31 #include "GitStatus.h"
  32 #include "HistoryDlg.h"
  33 #include "Hooks.h"
  34 #include "UnicodeUtils.h"
  35 #include "../TGitCache/CacheInterface.h"
  36 #include "ProgressDlg.h"
  37 #include "ShellUpdater.h"
  38 #include "Commands/PushCommand.h"
  39 #include "PatchViewDlg.h"
  40 #include "COMError.h"
  41 #include "Globals.h"
  42 #include "SysProgressDlg.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
  52 IMPLEMENT_DYNAMIC(CCommitDlg, CResizableStandAloneDialog)
  53 CCommitDlg::CCommitDlg(CWnd* pParent /*=NULL*/)
  54         : CResizableStandAloneDialog(CCommitDlg::IDD, pParent)
  55         , m_bRecursive(FALSE)
  56         , m_bShowUnversioned(FALSE)
  57         , m_bBlock(FALSE)
  58         , m_bThreadRunning(FALSE)
  59         , m_bRunThread(FALSE)
  60         , m_pThread(NULL)
  61         , m_bWholeProject(FALSE)
  62         , m_bKeepChangeList(TRUE)
  63         , m_bDoNotAutoselectSubmodules(FALSE)
  64         , m_itemsCount(0)
  65         , m_bSelectFilesForCommit(TRUE)
  66         , m_bNoPostActions(FALSE)
  67         , m_bAutoClose(false)
  68         , m_bSetCommitDateTime(FALSE)
  69         , m_bCreateNewBranch(FALSE)
  70         , m_bCreateTagAfterCommit(FALSE)
  71 {
  72         this->m_bCommitAmend=FALSE;
  73         m_bPushAfterCommit = FALSE;
  74 }
  75
  76 CCommitDlg::~CCommitDlg()
  77 {
  78         if(m_pThread != NULL)
  79         {
  80                 delete m_pThread;
  81         }
  82 }
  83
  84 void CCommitDlg::DoDataExchange(CDataExchange* pDX)
  85 {
  86         CResizableStandAloneDialog::DoDataExchange(pDX);
  87         DDX_Control(pDX, IDC_FILELIST, m_ListCtrl);
  88         DDX_Control(pDX, IDC_LOGMESSAGE, m_cLogMessage);
  89         DDX_Check(pDX, IDC_SHOWUNVERSIONED, m_bShowUnversioned);
  90         DDX_Check(pDX, IDC_COMMIT_SETDATETIME, m_bSetCommitDateTime);
  91         DDX_Check(pDX, IDC_CHECK_NEWBRANCH, m_bCreateNewBranch);
  92         DDX_Text(pDX, IDC_NEWBRANCH, m_sCreateNewBranch);
  93         DDX_Control(pDX, IDC_SELECTALL, m_SelectAll);
  94         DDX_Text(pDX, IDC_BUGID, m_sBugID);
  95         DDX_Check(pDX, IDC_WHOLE_PROJECT, m_bWholeProject);
  96         DDX_Control(pDX, IDC_SPLITTER, m_wndSplitter);
  97         DDX_Check(pDX, IDC_KEEPLISTS, m_bKeepChangeList);
  98         DDX_Check(pDX, IDC_NOAUTOSELECTSUBMODULES, m_bDoNotAutoselectSubmodules);
  99         DDX_Check(pDX,IDC_COMMIT_AMEND,m_bCommitAmend);
 100         DDX_Check(pDX,IDC_COMMIT_AMENDDIFF,m_bAmendDiffToLastCommit);
 101         DDX_Control(pDX,IDC_VIEW_PATCH,m_ctrlShowPatch);
 102         DDX_Control(pDX, IDC_COMMIT_DATEPICKER, m_CommitDate);
 103         DDX_Control(pDX, IDC_COMMIT_TIMEPICKER, m_CommitTime);
 104 }
 105
 106 BEGIN_MESSAGE_MAP(CCommitDlg, CResizableStandAloneDialog)
 107         ON_BN_CLICKED(IDC_SELECTALL, OnBnClickedSelectall)
 108         ON_BN_CLICKED(IDHELP, OnBnClickedHelp)
 109         ON_BN_CLICKED(IDC_SHOWUNVERSIONED, OnBnClickedShowunversioned)
 110         ON_NOTIFY(SCN_UPDATEUI, IDC_LOGMESSAGE, OnScnUpdateUI)
 111 //      ON_BN_CLICKED(IDC_HISTORY, OnBnClickedHistory)
 112         ON_BN_CLICKED(IDC_BUGTRAQBUTTON, OnBnClickedBugtraqbutton)
 113         ON_EN_CHANGE(IDC_LOGMESSAGE, OnEnChangeLogmessage)
 114         ON_REGISTERED_MESSAGE(CGitStatusListCtrl::GITSLNM_ITEMCOUNTCHANGED, OnGitStatusListCtrlItemCountChanged)
 115         ON_REGISTERED_MESSAGE(CGitStatusListCtrl::GITSLNM_NEEDSREFRESH, OnGitStatusListCtrlNeedsRefresh)
 116         ON_REGISTERED_MESSAGE(CGitStatusListCtrl::GITSLNM_ADDFILE, OnFileDropped)
 117         ON_REGISTERED_MESSAGE(CGitStatusListCtrl::GITSLNM_CHECKCHANGED, &CCommitDlg::OnGitStatusListCtrlCheckChanged)
 118         ON_REGISTERED_MESSAGE(CGitStatusListCtrl::GITSLNM_ITEMCHANGED, &CCommitDlg::OnGitStatusListCtrlItemChanged)
 119
 120         ON_REGISTERED_MESSAGE(WM_AUTOLISTREADY, OnAutoListReady)
 121         ON_WM_TIMER()
 122         ON_WM_SIZE()
 123         ON_STN_CLICKED(IDC_EXTERNALWARNING, &CCommitDlg::OnStnClickedExternalwarning)
 124         ON_BN_CLICKED(IDC_SIGNOFF, &CCommitDlg::OnBnClickedSignOff)
 125         ON_BN_CLICKED(IDC_COMMIT_AMEND, &CCommitDlg::OnBnClickedCommitAmend)
 126         ON_BN_CLICKED(IDC_WHOLE_PROJECT, &CCommitDlg::OnBnClickedWholeProject)
 127         ON_COMMAND(ID_FOCUS_MESSAGE,&CCommitDlg::OnFocusMessage)
 128         ON_STN_CLICKED(IDC_VIEW_PATCH, &CCommitDlg::OnStnClickedViewPatch)
 129         ON_WM_MOVE()
 130         ON_WM_MOVING()
 131         ON_WM_SIZING()
 132         ON_NOTIFY(HDN_ITEMCHANGED, 0, &CCommitDlg::OnHdnItemchangedFilelist)
 133         ON_BN_CLICKED(IDC_COMMIT_AMENDDIFF, &CCommitDlg::OnBnClickedCommitAmenddiff)
 134         ON_BN_CLICKED(IDC_NOAUTOSELECTSUBMODULES, &CCommitDlg::OnBnClickedNoautoselectsubmodules)
 135         ON_BN_CLICKED(IDC_COMMIT_SETDATETIME, &CCommitDlg::OnBnClickedCommitSetDateTime)
 136         ON_BN_CLICKED(IDC_CHECK_NEWBRANCH, &CCommitDlg::OnBnClickedCheckNewBranch)
 137 END_MESSAGE_MAP()
 138
 139 BOOL CCommitDlg::OnInitDialog()
 140 {
 141         CResizableStandAloneDialog::OnInitDialog();
 142         CAppUtils::MarkWindowAsUnpinnable(m_hWnd);
 143
 144         CAppUtils::GetCommitTemplate(this->m_sLogMessage);
 145
 146         CString dotGitPath;
 147         g_GitAdminDir.GetAdminDirPath(g_Git.m_CurrentDir, dotGitPath);
 148         if(PathFileExists(dotGitPath + _T("MERGE_MSG")))
 149         {
 150                 CStdioFile file;
 151                 if(file.Open(dotGitPath + _T("MERGE_MSG"), CFile::modeRead))
 152                 {
 153                         CString str;
 154                         while(file.ReadString(str))
 155                         {
 156                                 m_sLogMessage += str;
 157                                 str.Empty();
 158                                 m_sLogMessage += _T("\n");
 159                         }
 160                 }
 161         }
 162
 163         if (CTGitPath(g_Git.m_CurrentDir).IsMergeActive())
 164                 DialogEnableWindow(IDC_CHECK_NEWBRANCH, FALSE);
 165
 166         m_regAddBeforeCommit = CRegDWORD(_T("Software\\TortoiseGit\\AddBeforeCommit"), TRUE);
 167         m_bShowUnversioned = m_regAddBeforeCommit;
 168
 169         m_History.SetMaxHistoryItems((LONG)CRegDWORD(_T("Software\\TortoiseGit\\MaxHistoryItems"), 25));
 170
 171         m_regKeepChangelists = CRegDWORD(_T("Software\\TortoiseGit\\KeepChangeLists"), FALSE);
 172         m_bKeepChangeList = m_regKeepChangelists;
 173
 174         m_regDoNotAutoselectSubmodules = CRegDWORD(_T("Software\\TortoiseGit\\DoNotAutoselectSubmodules"), FALSE);
 175         m_bDoNotAutoselectSubmodules = m_regDoNotAutoselectSubmodules;
 176
 177         m_hAccel = LoadAccelerators(AfxGetResourceHandle(),MAKEINTRESOURCE(IDR_ACC_COMMITDLG));
 178
 179 //      GitConfig config;
 180 //      m_bWholeProject = config.KeepLocks();
 181
 182         if(this->m_pathList.GetCount() == 0)
 183                 m_bWholeProject =true;
 184
 185         if(this->m_pathList.GetCount() == 1 && m_pathList[0].IsEmpty())
 186                 m_bWholeProject =true;
 187
 188         SetDlgTitle();
 189
 190         UpdateData(FALSE);
 191
 192         m_ListCtrl.Init(GITSLC_COLEXT | GITSLC_COLSTATUS | GITSLC_COLADD |GITSLC_COLDEL, _T("CommitDlg"),(GITSLC_POPALL ^ (GITSLC_POPCOMMIT | GITSLC_POPSAVEAS)));
 193         m_ListCtrl.SetSelectButton(&m_SelectAll);
 194         m_ListCtrl.SetStatLabel(GetDlgItem(IDC_STATISTICS));
 195         m_ListCtrl.SetCancelBool(&m_bCancelled);
 196         m_ListCtrl.SetEmptyString(IDS_COMMITDLG_NOTHINGTOCOMMIT);
 197         m_ListCtrl.EnableFileDrop();
 198         m_ListCtrl.SetBackgroundImage(IDI_COMMIT_BKG);
 199
 200         //this->DialogEnableWindow(IDC_COMMIT_AMEND,FALSE);
 201         m_ProjectProperties.ReadPropsPathList(m_pathList);
 202
 203         m_cLogMessage.Init(m_ProjectProperties);
 204         m_cLogMessage.SetFont((CString)CRegString(_T("Software\\TortoiseGit\\LogFontName"), _T("Courier New")), (DWORD)CRegDWORD(_T("Software\\TortoiseGit\\LogFontSize"), 8));
 205         m_cLogMessage.RegisterContextMenuHandler(this);
 206
 207         OnEnChangeLogmessage();
 208
 209         m_tooltips.Create(this);
 210         m_tooltips.AddTool(IDC_EXTERNALWARNING, IDS_COMMITDLG_EXTERNALS);
 211         m_tooltips.AddTool(IDC_COMMIT_AMEND,IDS_COMMIT_AMEND_TT);
 212 //      m_tooltips.AddTool(IDC_HISTORY, IDS_COMMITDLG_HISTORY_TT);
 213
 214         m_SelectAll.SetCheck(BST_INDETERMINATE);
 215
 216         CBugTraqAssociations bugtraq_associations;
 217         bugtraq_associations.Load();
 218
 219         if (bugtraq_associations.FindProvider(g_Git.m_CurrentDir, &m_bugtraq_association))
 220         {
 221                 GetDlgItem(IDC_BUGID)->ShowWindow(SW_HIDE);
 222                 GetDlgItem(IDC_BUGIDLABEL)->ShowWindow(SW_HIDE);
 223
 224                 CComPtr<IBugTraqProvider> pProvider;
 225                 HRESULT hr = pProvider.CoCreateInstance(m_bugtraq_association.GetProviderClass());
 226                 if (SUCCEEDED(hr))
 227                 {
 228                         m_BugTraqProvider = pProvider;
 229                         BSTR temp = NULL;
 230                         if (SUCCEEDED(hr = pProvider->GetLinkText(GetSafeHwnd(), m_bugtraq_association.GetParameters().AllocSysString(), &temp)))
 231                         {
 232                                 SetDlgItemText(IDC_BUGTRAQBUTTON, temp);
 233                                 GetDlgItem(IDC_BUGTRAQBUTTON)->EnableWindow(TRUE);
 234                                 GetDlgItem(IDC_BUGTRAQBUTTON)->ShowWindow(SW_SHOW);
 235                         }
 236
 237                         SysFreeString(temp);
 238                 }
 239
 240                 GetDlgItem(IDC_LOGMESSAGE)->SetFocus();
 241         }
 242         else if (!m_ProjectProperties.sMessage.IsEmpty())
 243         {
 244                 GetDlgItem(IDC_BUGID)->ShowWindow(SW_SHOW);
 245                 GetDlgItem(IDC_BUGIDLABEL)->ShowWindow(SW_SHOW);
 246                 if (!m_ProjectProperties.sLabel.IsEmpty())
 247                         SetDlgItemText(IDC_BUGIDLABEL, m_ProjectProperties.sLabel);
 248                 GetDlgItem(IDC_BUGTRAQBUTTON)->ShowWindow(SW_HIDE);
 249                 GetDlgItem(IDC_BUGTRAQBUTTON)->EnableWindow(FALSE);
 250                 GetDlgItem(IDC_BUGID)->SetFocus();
 251                 CString sBugID = m_ProjectProperties.GetBugIDFromLog(m_sLogMessage);
 252                 if (!sBugID.IsEmpty())
 253                 {
 254                         SetDlgItemText(IDC_BUGID, sBugID);
 255                 }
 256         }
 257         else
 258         {
 259                 GetDlgItem(IDC_BUGID)->ShowWindow(SW_HIDE);
 260                 GetDlgItem(IDC_BUGIDLABEL)->ShowWindow(SW_HIDE);
 261                 GetDlgItem(IDC_BUGTRAQBUTTON)->ShowWindow(SW_HIDE);
 262                 GetDlgItem(IDC_BUGTRAQBUTTON)->EnableWindow(FALSE);
 263                 GetDlgItem(IDC_LOGMESSAGE)->SetFocus();
 264         }
 265
 266         if (!m_sLogMessage.IsEmpty())
 267                 m_cLogMessage.SetText(m_sLogMessage);
 268
 269         GetWindowText(m_sWindowTitle);
 270
 271         AdjustControlSize(IDC_SHOWUNVERSIONED);
 272         AdjustControlSize(IDC_SELECTALL);
 273         AdjustControlSize(IDC_WHOLE_PROJECT);
 274
 275         GetClientRect(m_DlgOrigRect);
 276         m_cLogMessage.GetClientRect(m_LogMsgOrigRect);
 277
 278         AddAnchor(IDC_COMMITLABEL, TOP_LEFT, TOP_RIGHT);
 279         AddAnchor(IDC_BUGIDLABEL, TOP_RIGHT);
 280         AddAnchor(IDC_BUGID, TOP_RIGHT);
 281         AddAnchor(IDC_BUGTRAQBUTTON, TOP_RIGHT);
 282         AddAnchor(IDC_COMMIT_TO, TOP_LEFT, TOP_RIGHT);
 283         AddAnchor(IDC_CHECK_NEWBRANCH, TOP_RIGHT);
 284         AddAnchor(IDC_NEWBRANCH, TOP_LEFT, TOP_RIGHT);
 285         AddAnchor(IDC_MESSAGEGROUP, TOP_LEFT, TOP_RIGHT);
 286 //      AddAnchor(IDC_HISTORY, TOP_LEFT);
 287         AddAnchor(IDC_LOGMESSAGE, TOP_LEFT, TOP_RIGHT);
 288         AddAnchor(IDC_SIGNOFF, TOP_RIGHT);
 289         AddAnchor(IDC_VIEW_PATCH, BOTTOM_RIGHT);
 290         AddAnchor(IDC_LISTGROUP, TOP_LEFT, BOTTOM_RIGHT);
 291         AddAnchor(IDC_SPLITTER, TOP_LEFT, TOP_RIGHT);
 292         AddAnchor(IDC_FILELIST, TOP_LEFT, BOTTOM_RIGHT);
 293         AddAnchor(IDC_SHOWUNVERSIONED, BOTTOM_LEFT);
 294         AddAnchor(IDC_SELECTALL, BOTTOM_LEFT);
 295         AddAnchor(IDC_EXTERNALWARNING, BOTTOM_RIGHT);
 296         AddAnchor(IDC_STATISTICS, BOTTOM_LEFT, BOTTOM_RIGHT);
 297         AddAnchor(IDC_TEXT_INFO, TOP_RIGHT);
 298         AddAnchor(IDC_WHOLE_PROJECT, BOTTOM_LEFT);
 299         AddAnchor(IDC_KEEPLISTS, BOTTOM_LEFT);
 300         AddAnchor(IDC_NOAUTOSELECTSUBMODULES, BOTTOM_LEFT);
 301         AddAnchor(IDOK, BOTTOM_RIGHT);
 302         AddAnchor(IDCANCEL, BOTTOM_RIGHT);
 303         AddAnchor(IDHELP, BOTTOM_RIGHT);
 304         AddAnchor(IDC_COMMIT_AMEND,TOP_LEFT);
 305         AddAnchor(IDC_COMMIT_AMENDDIFF,TOP_LEFT);
 306         AddAnchor(IDC_COMMIT_SETDATETIME,TOP_LEFT);
 307         AddAnchor(IDC_COMMIT_DATEPICKER,TOP_LEFT);
 308         AddAnchor(IDC_COMMIT_TIMEPICKER,TOP_LEFT);
 309
 310         if (hWndExplorer)
 311                 CenterWindow(CWnd::FromHandle(hWndExplorer));
 312         EnableSaveRestore(_T("CommitDlg"));
 313         DWORD yPos = CRegDWORD(_T("Software\\TortoiseGit\\TortoiseProc\\ResizableState\\CommitDlgSizer"));
 314         RECT rcDlg, rcLogMsg, rcFileList;
 315         GetClientRect(&rcDlg);
 316         m_cLogMessage.GetWindowRect(&rcLogMsg);
 317         ScreenToClient(&rcLogMsg);
 318         m_ListCtrl.GetWindowRect(&rcFileList);
 319         ScreenToClient(&rcFileList);
 320         if (yPos)
 321         {
 322                 RECT rectSplitter;
 323                 m_wndSplitter.GetWindowRect(&rectSplitter);
 324                 ScreenToClient(&rectSplitter);
 325                 int delta = yPos - rectSplitter.top;
 326                 if ((rcLogMsg.bottom + delta > rcLogMsg.top)&&(rcLogMsg.bottom + delta < rcFileList.bottom - 30))
 327                 {
 328                         m_wndSplitter.SetWindowPos(NULL, 0, yPos, 0, 0, SWP_NOSIZE);
 329                         DoSize(delta);
 330                 }
 331         }
 332
 333         // add all directories to the watcher
 334         /*
 335         for (int i=0; i<m_pathList.GetCount(); ++i)
 336         {
 337                 if (m_pathList[i].IsDirectory())
 338                         m_pathwatcher.AddPath(m_pathList[i]);
 339         }*/
 340
 341         m_updatedPathList = m_pathList;
 342
 343         //first start a thread to obtain the file list with the status without
 344         //blocking the dialog
 345         InterlockedExchange(&m_bBlock, TRUE);
 346         m_pThread = AfxBeginThread(StatusThreadEntry, this, THREAD_PRIORITY_NORMAL,0,CREATE_SUSPENDED);
 347         if (m_pThread==NULL)
 348         {
 349                 CMessageBox::Show(this->m_hWnd, IDS_ERR_THREADSTARTFAILED, IDS_APPNAME, MB_OK | MB_ICONERROR);
 350                 InterlockedExchange(&m_bBlock, FALSE);
 351         }
 352         else
 353         {
 354                 m_pThread->m_bAutoDelete = FALSE;
 355                 m_pThread->ResumeThread();
 356         }
 357         CRegDWORD err = CRegDWORD(_T("Software\\TortoiseGit\\ErrorOccurred"), FALSE);
 358         CRegDWORD historyhint = CRegDWORD(_T("Software\\TortoiseGit\\HistoryHintShown"), FALSE);
 359         if ((((DWORD)err)!=FALSE)&&((((DWORD)historyhint)==FALSE)))
 360         {
 361                 historyhint = TRUE;
 362 //              ShowBalloon(IDC_HISTORY, IDS_COMMITDLG_HISTORYHINT_TT, IDI_INFORMATION);
 363         }
 364         err = FALSE;
 365
 366         if (g_Git.IsInitRepos())
 367         {
 368                 m_bCommitAmend = FALSE;
 369                 GetDlgItem(IDC_COMMIT_AMEND)->EnableWindow(FALSE);
 370                 UpdateData(FALSE);
 371         }
 372         else
 373         {
 374                 if(m_bCommitAmend)
 375                 {
 376                         GetDlgItem(IDC_COMMIT_AMEND)->EnableWindow(FALSE);
 377                         GetDlgItem(IDC_COMMIT_AMENDDIFF)->ShowWindow(SW_SHOW);
 378                 }
 379
 380                 CGitHash hash = g_Git.GetHash(_T("HEAD"));
 381                 GitRev headRevision;
 382                 headRevision.GetParentFromHash(hash);
 383                 // do not allow to show diff to "last" revision if it has more that one parent
 384                 if (headRevision.ParentsCount() != 1)
 385                 {
 386                         m_bAmendDiffToLastCommit = true;
 387                         UpdateData(FALSE);
 388                         GetDlgItem(IDC_COMMIT_AMENDDIFF)->EnableWindow(FALSE);
 389                 }
 390         }
 391
 392         this->m_ctrlShowPatch.SetURL(CString());
 393
 394         BOOL viewPatchEnabled = FALSE;
 395         m_ProjectProperties.GetBOOLProps(viewPatchEnabled, _T("tgit.commitshowpatch"));
 396         if (viewPatchEnabled)
 397                 OnStnClickedViewPatch();
 398
 399         return FALSE;  // return TRUE unless you set the focus to a control
 400         // EXCEPTION: OCX Property Pages should return FALSE
 401 }
 402
 403 void CCommitDlg::OnOK()
 404 {
 405         if (m_bBlock)
 406                 return;
 407         if (m_bThreadRunning)
 408         {
 409                 m_bCancelled = true;
 410                 InterlockedExchange(&m_bRunThread, FALSE);
 411                 WaitForSingleObject(m_pThread->m_hThread, 1000);
 412                 if (m_bThreadRunning)
 413                 {
 414                         // we gave the thread a chance to quit. Since the thread didn't
 415                         // listen to us we have to kill it.
 416                         TerminateThread(m_pThread->m_hThread, (DWORD)-1);
 417                         InterlockedExchange(&m_bThreadRunning, FALSE);
 418                 }
 419         }
 420         this->UpdateData();
 421
 422         if (m_bCreateNewBranch && !g_Git.IsBranchNameValid(m_sCreateNewBranch))
 423         {
 424                 ShowEditBalloon(IDC_NEWBRANCH, IDS_B_T_NOTEMPTY, TTI_ERROR);
 425                 return;
 426         }
 427
 428         CString id;
 429         GetDlgItemText(IDC_BUGID, id);
 430         if (!m_ProjectProperties.CheckBugID(id))
 431         {
 432                 ShowEditBalloon(IDC_BUGID, IDS_COMMITDLG_ONLYNUMBERS, TTI_ERROR);
 433                 return;
 434         }
 435         m_sLogMessage = m_cLogMessage.GetText();
 436         if ( m_sLogMessage.IsEmpty() )
 437         {
 438                 // no message entered, go round again
 439                 CMessageBox::Show(this->m_hWnd, IDS_COMMITDLG_NOMESSAGE, IDS_APPNAME, MB_OK | MB_ICONERROR);
 440                 return;
 441         }
 442         if ((m_ProjectProperties.bWarnIfNoIssue) && (id.IsEmpty() && !m_ProjectProperties.HasBugID(m_sLogMessage)))
 443         {
 444                 if (CMessageBox::Show(this->m_hWnd, IDS_COMMITDLG_NOISSUEWARNING, IDS_APPNAME, MB_YESNO | MB_ICONWARNING)!=IDYES)
 445                         return;
 446         }
 447
 448         BOOL bWarnNoSignedOffBy = FALSE;
 449         ProjectProperties::GetBOOLProps(bWarnNoSignedOffBy, _T("tgit.warnnosignedoffby"));
 450         if (bWarnNoSignedOffBy == TRUE && m_cLogMessage.GetText().Find(GetSignedOffByLine()) == -1)
 451         {
 452                 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);
 453                 if (retval == 1)
 454                 {
 455                         OnBnClickedSignOff();
 456                         m_sLogMessage = m_cLogMessage.GetText();
 457                 }
 458                 else if (retval == 3)
 459                         return;
 460         }
 461
 462         m_ListCtrl.WriteCheckedNamesToPathList(m_selectedPathList);
 463         m_pathwatcher.Stop();
 464         InterlockedExchange(&m_bBlock, TRUE);
 465         CDWordArray arDeleted;
 466         //first add all the unversioned files the user selected
 467         //and check if all versioned files are selected
 468         int nchecked = 0;
 469         m_bRecursive = true;
 470         int nListItems = m_ListCtrl.GetItemCount();
 471
 472         CTGitPathList itemsToAdd;
 473         CTGitPathList itemsToRemove;
 474         //std::set<CString> checkedLists;
 475         //std::set<CString> uncheckedLists;
 476
 477                 // now let the bugtraq plugin check the commit message
 478         CComPtr<IBugTraqProvider2> pProvider2 = NULL;
 479         if (m_BugTraqProvider)
 480         {
 481                 HRESULT hr = m_BugTraqProvider.QueryInterface(&pProvider2);
 482                 if (SUCCEEDED(hr))
 483                 {
 484                         BSTR temp = NULL;
 485                         CString common = g_Git.m_CurrentDir;
 486                         BSTR repositoryRoot = common.AllocSysString();
 487                         BSTR parameters = m_bugtraq_association.GetParameters().AllocSysString();
 488                         BSTR commonRoot = SysAllocString(m_pathList.GetCommonRoot().GetDirectory().GetWinPath());
 489                         BSTR commitMessage = m_sLogMessage.AllocSysString();
 490                         SAFEARRAY *pathList = SafeArrayCreateVector(VT_BSTR, 0, m_selectedPathList.GetCount());
 491
 492                         for (LONG index = 0; index < m_selectedPathList.GetCount(); ++index)
 493                                 SafeArrayPutElement(pathList, &index, m_selectedPathList[index].GetGitPathString().AllocSysString());
 494
 495                         if (FAILED(hr = pProvider2->CheckCommit(GetSafeHwnd(), parameters, repositoryRoot, commonRoot, pathList, commitMessage, &temp)))
 496                         {
 497                                 COMError ce(hr);
 498                                 CString sErr;
 499                                 sErr.Format(IDS_ERR_FAILEDISSUETRACKERCOM, m_bugtraq_association.GetProviderName(), ce.GetMessageAndDescription().c_str());
 500                                 CMessageBox::Show(m_hWnd, sErr, _T("TortoiseGit"), MB_ICONERROR);
 501                         }
 502                         else
 503                         {
 504                                 CString sError = temp;
 505                                 if (!sError.IsEmpty())
 506                                 {
 507                                         CMessageBox::Show(m_hWnd, sError, _T("TortoiseGit"), MB_ICONERROR);
 508                                         return;
 509                                 }
 510                                 SysFreeString(temp);
 511                         }
 512                 }
 513         }
 514
 515         //CString checkedfiles;
 516         //CString uncheckedfiles;
 517
 518         CString cmd;
 519         CString out;
 520
 521         bool bAddSuccess=true;
 522         bool bCloseCommitDlg=false;
 523
 524         CSysProgressDlg sysProgressDlg;
 525         if (nListItems >= 25 && sysProgressDlg.IsValid())
 526         {
 527                 sysProgressDlg.SetTitle(CString(MAKEINTRESOURCE(IDS_PROC_COMMIT_PREPARECOMMIT)));
 528                 sysProgressDlg.SetLine(1, CString(MAKEINTRESOURCE(IDS_PROC_COMMIT_UPDATEINDEX)));
 529                 sysProgressDlg.SetTime(true);
 530                 sysProgressDlg.SetShowProgressBar(true);
 531                 sysProgressDlg.ShowModal(this, true);
 532         }
 533
 534         CBlockCacheForPath cacheBlock(g_Git.m_CurrentDir);
 535         DWORD currentTicks = GetTickCount();
 536
 537         for (int j=0; j<nListItems; j++)
 538         {
 539                 CTGitPath *entry = (CTGitPath*)m_ListCtrl.GetItemData(j);
 540                 if (sysProgressDlg.IsValid())
 541                 {
 542                         if (GetTickCount() - currentTicks > 1000 || j == nListItems - 1 || j == 0)
 543                         {
 544                                 sysProgressDlg.SetLine(2, entry->GetGitPathString(), true);
 545                                 sysProgressDlg.SetProgress(j, nListItems);
 546                                 AfxGetThread()->PumpMessage(); // process messages, in order to avoid freezing; do not call this too: this takes time!
 547                                 currentTicks = GetTickCount();
 548                         }
 549                 }
 550                 //const CGitStatusListCtrl::FileEntry * entry = m_ListCtrl.GetListEntry(j);
 551                 if (entry->m_Checked)
 552                 {
 553 #if 0
 554                         if (entry->status == Git_wc_status_unversioned)
 555                         {
 556                                 itemsToAdd.AddPath(entry->GetPath());
 557                         }
 558                         if (entry->status == Git_wc_status_conflicted)
 559                         {
 560                                 bHasConflicted = true;
 561                         }
 562                         if (entry->status == Git_wc_status_missing)
 563                         {
 564                                 itemsToRemove.AddPath(entry->GetPath());
 565                         }
 566                         if (entry->status == Git_wc_status_deleted)
 567                         {
 568                                 arDeleted.Add(j);
 569                         }
 570                         if (entry->IsInExternal())
 571                         {
 572                                 bCheckedInExternal = true;
 573                         }
 574 #endif
 575                         if( entry->m_Action & CTGitPath::LOGACTIONS_UNVER)
 576                                 cmd.Format(_T("git.exe add -f -- \"%s\""),entry->GetGitPathString());
 577                         else if ( entry->m_Action & CTGitPath::LOGACTIONS_DELETED)
 578                                 cmd.Format(_T("git.exe update-index --force-remove -- \"%s\""),entry->GetGitPathString());
 579                         else
 580                                 cmd.Format(_T("git.exe update-index  -- \"%s\""),entry->GetGitPathString());
 581
 582                         if (g_Git.Run(cmd, &out, CP_UTF8))
 583                         {
 584                                 CMessageBox::Show(NULL,out,_T("TortoiseGit"),MB_OK|MB_ICONERROR);
 585                                 bAddSuccess = false ;
 586                                 break;
 587                         }
 588
 589                         if( entry->m_Action & CTGitPath::LOGACTIONS_REPLACED)
 590                                 cmd.Format(_T("git.exe rm -- \"%s\""), entry->GetGitOldPathString());
 591
 592                         g_Git.Run(cmd, &out, CP_UTF8);
 593
 594                         nchecked++;
 595
 596                         //checkedLists.insert(entry->GetGitPathString());
 597 //                      checkedfiles += _T("\"")+entry->GetGitPathString()+_T("\" ");
 598                 }
 599                 else
 600                 {
 601                         //uncheckedLists.insert(entry->GetGitPathString());
 602                         if(entry->m_Action & CTGitPath::LOGACTIONS_ADDED)
 603                         {       //To init git repository, there are not HEAD, so we can use git reset command
 604                                 cmd.Format(_T("git.exe rm -f --cache -- \"%s\""),entry->GetGitPathString());
 605                                 if (g_Git.Run(cmd, &out, CP_UTF8))
 606                                 {
 607                                         CMessageBox::Show(NULL,out,_T("TortoiseGit"),MB_OK|MB_ICONERROR);
 608                                         bAddSuccess = false ;
 609                                         bCloseCommitDlg=false;
 610                                         break;
 611                                 }
 612
 613                         }
 614                         else if(!( entry->m_Action & CTGitPath::LOGACTIONS_UNVER ) )
 615                         {
 616                                 if (m_bCommitAmend && !m_bAmendDiffToLastCommit)
 617                                 {
 618                                         cmd.Format(_T("git.exe reset HEAD~2 -- \"%s\""), entry->GetGitPathString());
 619                                 }
 620                                 else
 621                                 {
 622                                         cmd.Format(_T("git.exe reset -- \"%s\""), entry->GetGitPathString());
 623                                 }
 624                                 if (g_Git.Run(cmd, &out, CP_UTF8))
 625                                 {
 626                                         /* when reset a unstage file will report error.
 627                                         CMessageBox::Show(NULL,out,_T("TortoiseGit"),MB_OK|MB_ICONERROR);
 628                                         bAddSuccess = false ;
 629                                         bCloseCommitDlg=false;
 630                                         break;
 631                                         */
 632                                 }
 633                                 // && !entry->IsDirectory()
 634                                 if (m_bCommitAmend && !m_bAmendDiffToLastCommit)
 635                                         continue;
 636                         }
 637
 638                 //      uncheckedfiles += _T("\"")+entry->GetGitPathString()+_T("\" ");
 639 #if 0
 640                         if ((entry->status != Git_wc_status_unversioned)        &&
 641                                 (entry->status != Git_wc_status_ignored))
 642                         {
 643                                 nUnchecked++;
 644                                 uncheckedLists.insert(entry->GetChangeList());
 645                                 if (m_bRecursive)
 646                                 {
 647                                         // This algorithm is for the sake of simplicity of the complexity O(N?
 648                                         for (int k=0; k<nListItems; k++)
 649                                         {
 650                                                 const CGitStatusListCtrl::FileEntry * entryK = m_ListCtrl.GetListEntry(k);
 651                                                 if (entryK->IsChecked() && entryK->GetPath().IsAncestorOf(entry->GetPath())  )
 652                                                 {
 653                                                         // Fall back to a non-recursive commit to prevent items being
 654                                                         // committed which aren't checked although its parent is checked
 655                                                         // (property change, directory deletion, ... )
 656                                                         m_bRecursive = false;
 657                                                         break;
 658                                                 }
 659                                         }
 660                                 }
 661                         }
 662 #endif
 663                 }
 664
 665                 if (sysProgressDlg.IsValid() && sysProgressDlg.HasUserCancelled())
 666                 {
 667                         bAddSuccess = false;
 668                         break;
 669                 }
 670
 671                 CShellUpdater::Instance().AddPathForUpdate(*entry);
 672         }
 673
 674         if (sysProgressDlg.IsValid())
 675                 sysProgressDlg.Stop();
 676
 677         if (bAddSuccess && m_bCreateNewBranch)
 678         {
 679                 if (g_Git.Run(_T("git branch ") + m_sCreateNewBranch, &out, CP_UTF8))
 680                 {
 681                         MessageBox(_T("Creating new branch failed:\n") + out, _T("TortoiseGit"), MB_OK | MB_ICONERROR);
 682                         bAddSuccess = false;
 683                 }
 684                 if (g_Git.Run(_T("git checkout ") + m_sCreateNewBranch, &out, CP_UTF8))
 685                 {
 686                         MessageBox(_T("Switching to new branch failed:\n") + out, _T("TortoiseGit"), MB_OK | MB_ICONERROR);
 687                         bAddSuccess = false;
 688                 }
 689         }
 690
 691         if (bAddSuccess && CheckHeadDetach())
 692                 bAddSuccess = false;
 693
 694         //if(uncheckedfiles.GetLength()>0)
 695         //{
 696         //      cmd.Format(_T("git.exe reset -- %s"),uncheckedfiles);
 697         //      g_Git.Run(cmd,&out);
 698         //}
 699
 700         m_sBugID.Trim();
 701         if (!m_sBugID.IsEmpty())
 702         {
 703                 m_sBugID.Replace(_T(", "), _T(","));
 704                 m_sBugID.Replace(_T(" ,"), _T(","));
 705                 CString sBugID = m_ProjectProperties.sMessage;
 706                 sBugID.Replace(_T("%BUGID%"), m_sBugID);
 707                 if (m_ProjectProperties.bAppend)
 708                         m_sLogMessage += _T("\n") + sBugID + _T("\n");
 709                 else
 710                         m_sLogMessage = sBugID + _T("\n") + m_sLogMessage;
 711         }
 712
 713         //if(checkedfiles.GetLength()>0)
 714         if (bAddSuccess && (nchecked || m_bCommitAmend ||  CTGitPath(g_Git.m_CurrentDir).IsMergeActive()))
 715         {
 716         //      cmd.Format(_T("git.exe update-index -- %s"),checkedfiles);
 717         //      g_Git.Run(cmd,&out);
 718
 719                 bCloseCommitDlg = true;
 720
 721                 CString tempfile=::GetTempFile();
 722
 723                 CAppUtils::SaveCommitUnicodeFile(tempfile,m_sLogMessage);
 724                 //file.WriteString(m_sLogMessage);
 725
 726                 CTGitPath path=g_Git.m_CurrentDir;
 727
 728                 BOOL IsGitSVN = path.GetAdminDirMask() & ITEMIS_GITSVN;
 729
 730                 out =_T("");
 731                 CString amend;
 732                 if(this->m_bCommitAmend)
 733                 {
 734                         amend=_T("--amend");
 735                 }
 736                 CString dateTime;
 737                 if (m_bSetCommitDateTime)
 738                 {
 739                         CTime date, time;
 740                         m_CommitDate.GetTime(date);
 741                         m_CommitTime.GetTime(time);
 742                         dateTime.Format(_T("--date=%sT%s"), date.Format(_T("%Y-%m-%d")), time.Format(_T("%H:%M:%S")));
 743                 }
 744                 cmd.Format(_T("git.exe commit %s %s -F \"%s\""), dateTime, amend, tempfile);
 745
 746                 CCommitProgressDlg progress;
 747                 progress.m_bBufferAll=true; // improve show speed when there are many file added.
 748                 progress.m_GitCmd=cmd;
 749                 progress.m_bShowCommand = FALSE;        // don't show the commit command
 750                 progress.m_PreText = out;                       // show any output already generated in log window
 751                 progress.m_bAutoCloseOnSuccess = m_bAutoClose;
 752
 753                 if (!m_bNoPostActions && !m_bAutoClose)
 754                 {
 755                         progress.m_PostCmdList.Add( IsGitSVN? CString(MAKEINTRESOURCE(IDS_MENUSVNDCOMMIT)): CString(MAKEINTRESOURCE(IDS_MENUPUSH)));
 756                         progress.m_PostCmdList.Add(CString(MAKEINTRESOURCE(IDS_PROC_COMMIT_RECOMMIT)));
 757                         progress.m_PostCmdList.Add(CString(MAKEINTRESOURCE(IDS_MENUTAG)));
 758                 }
 759
 760                 m_PostCmd = IsGitSVN? GIT_POST_CMD_DCOMMIT:GIT_POST_CMD_PUSH;
 761
 762                 DWORD userResponse = progress.DoModal();
 763
 764                 if(progress.m_GitStatus || userResponse == (IDC_PROGRESS_BUTTON1+1))
 765                 {
 766                         bCloseCommitDlg = false;
 767                         if( userResponse == (IDC_PROGRESS_BUTTON1+1 ))
 768                         {
 769                                 this->m_sLogMessage.Empty();
 770                                 m_cLogMessage.SetText(m_sLogMessage);
 771                         }
 772
 773                         this->Refresh();
 774                 }
 775                 else if(userResponse == IDC_PROGRESS_BUTTON1 + 2)
 776                 {
 777                         m_bCreateTagAfterCommit=true;
 778                 }
 779                 else if(userResponse == IDC_PROGRESS_BUTTON1)
 780                 {
 781                         //User pressed 'Push' button after successful commit.
 782                         m_bPushAfterCommit=true;
 783                 }
 784
 785                 CFile::Remove(tempfile);
 786
 787                 if (m_BugTraqProvider && progress.m_GitStatus == 0)
 788                 {
 789                         CComPtr<IBugTraqProvider2> pProvider = NULL;
 790                         HRESULT hr = m_BugTraqProvider.QueryInterface(&pProvider);
 791                         if (SUCCEEDED(hr))
 792                         {
 793                                 BSTR commonRoot = SysAllocString(g_Git.m_CurrentDir);
 794                                 SAFEARRAY *pathList = SafeArrayCreateVector(VT_BSTR, 0,this->m_selectedPathList.GetCount());
 795
 796                                 for (LONG index = 0; index < m_selectedPathList.GetCount(); ++index)
 797                                         SafeArrayPutElement(pathList, &index, m_selectedPathList[index].GetGitPathString().AllocSysString());
 798
 799                                 BSTR logMessage = m_sLogMessage.AllocSysString();
 800
 801                                 CGitHash hash=g_Git.GetHash(_T("HEAD"));
 802                                 LONG version = g_Git.Hash2int(hash);
 803
 804                                 BSTR temp = NULL;
 805                                 if (FAILED(hr = pProvider->OnCommitFinished(GetSafeHwnd(),
 806                                         commonRoot,
 807                                         pathList,
 808                                         logMessage,
 809                                         (LONG)version,
 810                                         &temp)))
 811                                 {
 812                                         CString sErr = temp;
 813                                         if (!sErr.IsEmpty())
 814                                                 CMessageBox::Show(NULL,(sErr),_T("TortoiseGit"),MB_OK|MB_ICONERROR);
 815                                         else
 816                                         {
 817                                                 COMError ce(hr);
 818                                                 sErr.Format(IDS_ERR_FAILEDISSUETRACKERCOM, ce.GetSource().c_str(), ce.GetMessageAndDescription().c_str());
 819                                                 CMessageBox::Show(NULL,(sErr),_T("TortoiseGit"),MB_OK|MB_ICONERROR);
 820                                         }
 821                                 }
 822
 823                                 SysFreeString(temp);
 824                         }
 825                 }
 826                 RestoreFiles(progress.m_GitStatus == 0);
 827         }
 828         else if(bAddSuccess)
 829         {
 830                 CMessageBox::Show(this->m_hWnd, IDS_ERROR_NOTHING_COMMIT, IDS_COMMIT_FINISH, MB_OK | MB_ICONINFORMATION);
 831                 bCloseCommitDlg=false;
 832         }
 833 #if 0
 834         if (m_pathwatcher.GetNumberOfChangedPaths() && m_bRecursive)
 835         {
 836                 // There are paths which got changed (touched at least).
 837                 // We have to find out if this affects the selection in the commit dialog
 838                 // If it could affect the selection, revert back to a non-recursive commit
 839                 CTGitPathList changedList = m_pathwatcher.GetChangedPaths();
 840                 changedList.RemoveDuplicates();
 841                 for (int i=0; i<changedList.GetCount(); ++i)
 842                 {
 843                         if (changedList[i].IsAdminDir())
 844                         {
 845                                 // something inside an admin dir was changed.
 846                                 // if it's the entries file, then we have to fully refresh because
 847                                 // files may have been added/removed from version control
 848                                 if ((changedList[i].GetWinPathString().Right(7).CompareNoCase(_T("entries")) == 0) &&
 849                                         (changedList[i].GetWinPathString().Find(_T("\\tmp\\"))<0))
 850                                 {
 851                                         m_bRecursive = false;
 852                                         break;
 853                                 }
 854                         }
 855                         else if (!m_ListCtrl.IsPathShown(changedList[i]))
 856                         {
 857                                 // a path which is not shown in the list has changed
 858                                 CGitStatusListCtrl::FileEntry * entry = m_ListCtrl.GetListEntry(changedList[i]);
 859                                 if (entry)
 860                                 {
 861                                         // check if the changed path would get committed by a recursive commit
 862                                         if ((!entry->IsFromDifferentRepository()) &&
 863                                                 (!entry->IsInExternal()) &&
 864                                                 (!entry->IsNested()) &&
 865                                                 (!entry->IsChecked()))
 866                                         {
 867                                                 m_bRecursive = false;
 868                                                 break;
 869                                         }
 870                                 }
 871                         }
 872                 }
 873         }
 874
 875
 876         // Now, do all the adds - make sure that the list is sorted so that parents
 877         // are added before their children
 878         itemsToAdd.SortByPathname();
 879         Git Git;
 880         if (!Git.Add(itemsToAdd, &m_ProjectProperties, Git_depth_empty, FALSE, FALSE, TRUE))
 881         {
 882                 CMessageBox::Show(m_hWnd, Git.GetLastErrorMessage(), _T("TortoiseGit"), MB_ICONERROR);
 883                 InterlockedExchange(&m_bBlock, FALSE);
 884                 Refresh();
 885                 return;
 886         }
 887
 888         // Remove any missing items
 889         // Not sure that this sort is really necessary - indeed, it might be better to do a reverse sort at this point
 890         itemsToRemove.SortByPathname();
 891         Git.Remove(itemsToRemove, TRUE);
 892
 893         //the next step: find all deleted files and check if they're
 894         //inside a deleted folder. If that's the case, then remove those
 895         //files from the list since they'll get deleted by the parent
 896         //folder automatically.
 897         m_ListCtrl.Block(TRUE, FALSE);
 898         INT_PTR nDeleted = arDeleted.GetCount();
 899         for (INT_PTR i=0; i<arDeleted.GetCount(); i++)
 900         {
 901                 if (m_ListCtrl.GetCheck(arDeleted.GetAt(i)))
 902                 {
 903                         const CTGitPath& path = m_ListCtrl.GetListEntry(arDeleted.GetAt(i))->GetPath();
 904                         if (path.IsDirectory())
 905                         {
 906                                 //now find all children of this directory
 907                                 for (int j=0; j<arDeleted.GetCount(); j++)
 908                                 {
 909                                         if (i!=j)
 910                                         {
 911                                                 CGitStatusListCtrl::FileEntry* childEntry = m_ListCtrl.GetListEntry(arDeleted.GetAt(j));
 912                                                 if (childEntry->IsChecked())
 913                                                 {
 914                                                         if (path.IsAncestorOf(childEntry->GetPath()))
 915                                                         {
 916                                                                 m_ListCtrl.SetEntryCheck(childEntry, arDeleted.GetAt(j), false);
 917                                                                 nDeleted--;
 918                                                         }
 919                                                 }
 920                                         }
 921                                 }
 922                         }
 923                 }
 924         }
 925         m_ListCtrl.Block(FALSE, FALSE);
 926
 927         if ((nUnchecked != 0)||(bCheckedInExternal)||(bHasConflicted)||(!m_bRecursive))
 928         {
 929                 //save only the files the user has checked into the temporary file
 930                 m_ListCtrl.WriteCheckedNamesToPathList(m_pathList);
 931         }
 932
 933         // the item count is used in the progress dialog to show the overall commit
 934         // progress.
 935         // deleted items only send one notification event, all others send two
 936         m_itemsCount = ((m_selectedPathList.GetCount() - nDeleted - itemsToRemove.GetCount()) * 2) + nDeleted + itemsToRemove.GetCount();
 937
 938         if ((m_bRecursive)&&(checkedLists.size() == 1))
 939         {
 940                 // all checked items belong to the same changelist
 941                 // find out if there are any unchecked items which belong to that changelist
 942                 if (uncheckedLists.find(*checkedLists.begin()) == uncheckedLists.end())
 943                         m_sChangeList = *checkedLists.begin();
 944         }
 945 #endif
 946         UpdateData();
 947         m_regAddBeforeCommit = m_bShowUnversioned;
 948         if (!GetDlgItem(IDC_WHOLE_PROJECT)->IsWindowEnabled())
 949                 m_bWholeProject = FALSE;
 950         m_regKeepChangelists = m_bKeepChangeList;
 951         m_regDoNotAutoselectSubmodules = m_bDoNotAutoselectSubmodules;
 952         if (!GetDlgItem(IDC_KEEPLISTS)->IsWindowEnabled())
 953                 m_bKeepChangeList = FALSE;
 954         InterlockedExchange(&m_bBlock, FALSE);
 955
 956         m_History.AddEntry(m_sLogMessage);
 957         m_History.Save();
 958
 959         SaveSplitterPos();
 960
 961         if( bCloseCommitDlg )
 962                 CResizableStandAloneDialog::OnOK();
 963
 964         CShellUpdater::Instance().Flush();
 965 }
 966
 967 void CCommitDlg::SaveSplitterPos()
 968 {
 969         if (!IsIconic())
 970         {
 971                 CRegDWORD regPos = CRegDWORD(_T("Software\\TortoiseGit\\TortoiseProc\\ResizableState\\CommitDlgSizer"));
 972                 RECT rectSplitter;
 973                 m_wndSplitter.GetWindowRect(&rectSplitter);
 974                 ScreenToClient(&rectSplitter);
 975                 regPos = rectSplitter.top;
 976         }
 977 }
 978
 979 UINT CCommitDlg::StatusThreadEntry(LPVOID pVoid)
 980 {
 981         return ((CCommitDlg*)pVoid)->StatusThread();
 982 }
 983
 984 UINT CCommitDlg::StatusThread()
 985 {
 986         //get the status of all selected file/folders recursively
 987         //and show the ones which have to be committed to the user
 988         //in a list control.
 989         InterlockedExchange(&m_bBlock, TRUE);
 990         InterlockedExchange(&m_bThreadRunning, TRUE);// so the main thread knows that this thread is still running
 991         InterlockedExchange(&m_bRunThread, TRUE);       // if this is set to FALSE, the thread should stop
 992
 993         m_pathwatcher.Stop();
 994
 995         g_Git.RefreshGitIndex();
 996
 997         m_bCancelled = false;
 998
 999         DialogEnableWindow(IDOK, false);
1000         DialogEnableWindow(IDC_SHOWUNVERSIONED, false);
1001         DialogEnableWindow(IDC_WHOLE_PROJECT, false);
1002         DialogEnableWindow(IDC_SELECTALL, false);
1003         DialogEnableWindow(IDC_NOAUTOSELECTSUBMODULES, false);
1004         GetDlgItem(IDC_EXTERNALWARNING)->ShowWindow(SW_HIDE);
1005         DialogEnableWindow(IDC_EXTERNALWARNING, false);
1006         // read the list of recent log entries before querying the WC for status
1007         // -> the user may select one and modify / update it while we are crawling the WC
1008
1009         if (m_History.GetCount()==0)
1010         {
1011                 CString reg;
1012                 reg.Format(_T("Software\\TortoiseGit\\History\\commit%s"), (LPCTSTR)m_ListCtrl.m_sUUID);
1013                 reg.Replace(_T(':'),_T('_'));
1014                 m_History.Load(reg, _T("logmsgs"));
1015         }
1016
1017         // Initialise the list control with the status of the files/folders below us
1018         m_ListCtrl.Clear();
1019         BOOL success;
1020         CTGitPathList *pList;
1021         m_ListCtrl.m_amend = (m_bCommitAmend==TRUE) && (m_bAmendDiffToLastCommit==FALSE);
1022         m_ListCtrl.m_bDoNotAutoselectSubmodules = (m_bDoNotAutoselectSubmodules == TRUE);
1023
1024         if(m_bWholeProject)
1025                 pList=NULL;
1026         else
1027                 pList = &m_pathList;
1028
1029         success=m_ListCtrl.GetStatus(pList);
1030
1031         //m_ListCtrl.UpdateFileList(git_revnum_t(GIT_REV_ZERO));
1032         if(this->m_bShowUnversioned)
1033                 m_ListCtrl.UpdateFileList(CGitStatusListCtrl::FILELIST_UNVER,true,pList);
1034
1035         m_ListCtrl.CheckIfChangelistsArePresent(false);
1036
1037         DWORD dwShow = GITSLC_SHOWVERSIONEDBUTNORMALANDEXTERNALSFROMDIFFERENTREPOS | GITSLC_SHOWLOCKS | GITSLC_SHOWINCHANGELIST;
1038         dwShow |= DWORD(m_regAddBeforeCommit) ? GITSLC_SHOWUNVERSIONED : 0;
1039         if (success)
1040         {
1041                 if (m_checkedPathList.GetCount())
1042                         m_ListCtrl.Show(dwShow, m_checkedPathList);
1043                 else
1044                 {
1045                         DWORD dwCheck = m_bSelectFilesForCommit ? dwShow : 0;
1046                         dwCheck &=~(CTGitPath::LOGACTIONS_UNVER); //don't check unversion file default.
1047                         m_ListCtrl.Show(dwShow, dwCheck);
1048                         m_bSelectFilesForCommit = true;
1049                 }
1050
1051                 if (m_ListCtrl.HasExternalsFromDifferentRepos())
1052                 {
1053                         GetDlgItem(IDC_EXTERNALWARNING)->ShowWindow(SW_SHOW);
1054                         DialogEnableWindow(IDC_EXTERNALWARNING, TRUE);
1055                 }
1056
1057                 SetDlgItemText(IDC_COMMIT_TO, g_Git.GetCurrentBranch());
1058                 m_tooltips.AddTool(GetDlgItem(IDC_STATISTICS), m_ListCtrl.GetStatisticsString());
1059         }
1060         if (!success)
1061         {
1062                 if (!m_ListCtrl.GetLastErrorMessage().IsEmpty())
1063                         m_ListCtrl.SetEmptyString(m_ListCtrl.GetLastErrorMessage());
1064                 m_ListCtrl.Show(dwShow);
1065         }
1066         //
1067         if ((m_ListCtrl.GetItemCount()==0)&&(m_ListCtrl.HasUnversionedItems())
1068                  && !PathFileExists(g_Git.m_CurrentDir+_T("\\.git\\MERGE_HEAD")))
1069         {
1070                 CString temp;
1071                 temp.LoadString(IDS_COMMITDLG_NOTHINGTOCOMMITUNVERSIONED);
1072                 if (CMessageBox::ShowCheck(m_hWnd, temp, _T("TortoiseGit"), MB_ICONINFORMATION | MB_YESNO, _T("NothingToCommitShowUnversioned"), NULL)==IDYES)
1073                 {
1074                         m_bShowUnversioned = TRUE;
1075                         GetDlgItem(IDC_SHOWUNVERSIONED)->SendMessage(BM_SETCHECK, BST_CHECKED);
1076                         DWORD dwShow = (DWORD)(GITSLC_SHOWVERSIONEDBUTNORMALANDEXTERNALSFROMDIFFERENTREPOS | GITSLC_SHOWUNVERSIONED | GITSLC_SHOWLOCKS);
1077                         m_ListCtrl.UpdateFileList(CGitStatusListCtrl::FILELIST_UNVER);
1078                         m_ListCtrl.Show(dwShow,dwShow&(~CTGitPath::LOGACTIONS_UNVER));
1079                 }
1080         }
1081
1082         SetDlgTitle();
1083
1084         m_autolist.clear();
1085         // we don't have to block the commit dialog while we fetch the
1086         // auto completion list.
1087         m_pathwatcher.ClearChangedPaths();
1088         InterlockedExchange(&m_bBlock, FALSE);
1089         if ((DWORD)CRegDWORD(_T("Software\\TortoiseGit\\Autocompletion"), TRUE)==TRUE)
1090         {
1091                 m_ListCtrl.Block(TRUE, TRUE);
1092                 GetAutocompletionList();
1093                 m_ListCtrl.Block(FALSE, FALSE);
1094         }
1095         UpdateOKButton();
1096         if (m_bRunThread)
1097         {
1098                 DialogEnableWindow(IDC_SHOWUNVERSIONED, true);
1099                 DialogEnableWindow(IDC_WHOLE_PROJECT, true);
1100                 DialogEnableWindow(IDC_SELECTALL, true);
1101                 DialogEnableWindow(IDC_NOAUTOSELECTSUBMODULES, true);
1102                 if (m_ListCtrl.HasChangeLists())
1103                         DialogEnableWindow(IDC_KEEPLISTS, true);
1104                 if (m_ListCtrl.HasLocks())
1105                         DialogEnableWindow(IDC_WHOLE_PROJECT, true);
1106                 // we have the list, now signal the main thread about it
1107                 SendMessage(WM_AUTOLISTREADY);  // only send the message if the thread wasn't told to quit!
1108         }
1109
1110         InterlockedExchange(&m_bRunThread, FALSE);
1111         InterlockedExchange(&m_bThreadRunning, FALSE);
1112         // force the cursor to normal
1113         RefreshCursor();
1114
1115         return 0;
1116 }
1117
1118 void CCommitDlg::SetDlgTitle()
1119 {
1120         if (m_sTitle.IsEmpty())
1121                 GetWindowText(m_sTitle);
1122
1123         if (m_bWholeProject)
1124                 CAppUtils::SetWindowTitle(m_hWnd, g_Git.m_CurrentDir, m_sTitle);
1125         else
1126         {
1127                 if (m_pathList.GetCount() == 1)
1128                         CAppUtils::SetWindowTitle(m_hWnd, (g_Git.m_CurrentDir + _T("\\") + m_pathList[0].GetUIPathString()).TrimRight('\\'), m_sTitle);
1129                 else
1130                         CAppUtils::SetWindowTitle(m_hWnd, g_Git.m_CurrentDir + _T("\\") + m_ListCtrl.GetCommonDirectory(false), m_sTitle);
1131         }
1132 }
1133
1134 void CCommitDlg::OnCancel()
1135 {
1136         m_bCancelled = true;
1137         m_pathwatcher.Stop();
1138
1139         if (m_bThreadRunning)
1140         {
1141                 InterlockedExchange(&m_bRunThread, FALSE);
1142                 WaitForSingleObject(m_pThread->m_hThread, 1000);
1143                 if (m_bThreadRunning)
1144                 {
1145                         // we gave the thread a chance to quit. Since the thread didn't
1146                         // listen to us we have to kill it.
1147                         TerminateThread(m_pThread->m_hThread, (DWORD)-1);
1148                         InterlockedExchange(&m_bThreadRunning, FALSE);
1149                 }
1150         }
1151         UpdateData();
1152         m_sBugID.Trim();
1153         m_sLogMessage = m_cLogMessage.GetText();
1154         if (!m_sBugID.IsEmpty())
1155         {
1156                 m_sBugID.Replace(_T(", "), _T(","));
1157                 m_sBugID.Replace(_T(" ,"), _T(","));
1158                 CString sBugID = m_ProjectProperties.sMessage;
1159                 sBugID.Replace(_T("%BUGID%"), m_sBugID);
1160                 if (m_ProjectProperties.bAppend)
1161                         m_sLogMessage += _T("\n") + sBugID + _T("\n");
1162                 else
1163                         m_sLogMessage = sBugID + _T("\n") + m_sLogMessage;
1164         }
1165         if (m_ProjectProperties.sLogTemplate.Compare(m_sLogMessage) != 0)
1166                 m_History.AddEntry(m_sLogMessage);
1167         m_History.Save();
1168         RestoreFiles();
1169         SaveSplitterPos();
1170         CResizableStandAloneDialog::OnCancel();
1171 }
1172
1173 void CCommitDlg::OnBnClickedSelectall()
1174 {
1175         m_tooltips.Pop();       // hide the tooltips
1176         UINT state = (m_SelectAll.GetState() & 0x0003);
1177         if (state == BST_INDETERMINATE)
1178         {
1179                 // It is not at all useful to manually place the checkbox into the indeterminate state...
1180                 // We will force this on to the unchecked state
1181                 state = BST_UNCHECKED;
1182                 m_SelectAll.SetCheck(state);
1183         }
1184         m_ListCtrl.SelectAll(state == BST_CHECKED);
1185 }
1186
1187 BOOL CCommitDlg::PreTranslateMessage(MSG* pMsg)
1188 {
1189         if (!m_bBlock)
1190                 m_tooltips.RelayEvent(pMsg);
1191
1192         if (m_hAccel)
1193         {
1194                 int ret = TranslateAccelerator(m_hWnd, m_hAccel, pMsg);
1195                 if (ret)
1196                         return TRUE;
1197         }
1198
1199         if (pMsg->message == WM_KEYDOWN)
1200         {
1201                 switch (pMsg->wParam)
1202                 {
1203                 case VK_F5:
1204                         {
1205                                 if (m_bBlock)
1206                                         return CResizableStandAloneDialog::PreTranslateMessage(pMsg);
1207                                 Refresh();
1208                         }
1209                         break;
1210                 case VK_RETURN:
1211                         {
1212                                 if (GetAsyncKeyState(VK_CONTROL)&0x8000)
1213                                 {
1214                                         if ( GetDlgItem(IDOK)->IsWindowEnabled() )
1215                                         {
1216                                                 PostMessage(WM_COMMAND, IDOK);
1217                                         }
1218                                         return TRUE;
1219                                 }
1220                                 if ( GetFocus()==GetDlgItem(IDC_BUGID) )
1221                                 {
1222                                         // Pressing RETURN in the bug id control
1223                                         // moves the focus to the message
1224                                         GetDlgItem(IDC_LOGMESSAGE)->SetFocus();
1225                                         return TRUE;
1226                                 }
1227                         }
1228                         break;
1229                 }
1230         }
1231
1232         return CResizableStandAloneDialog::PreTranslateMessage(pMsg);
1233 }
1234
1235 void CCommitDlg::Refresh()
1236 {
1237         if (m_bThreadRunning)
1238                 return;
1239
1240         InterlockedExchange(&m_bBlock, TRUE);
1241         m_pThread = AfxBeginThread(StatusThreadEntry, this, THREAD_PRIORITY_NORMAL,0,CREATE_SUSPENDED);
1242         if (m_pThread==NULL)
1243         {
1244                 CMessageBox::Show(this->m_hWnd, IDS_ERR_THREADSTARTFAILED, IDS_APPNAME, MB_OK | MB_ICONERROR);
1245                 InterlockedExchange(&m_bBlock, FALSE);
1246         }
1247         else
1248         {
1249                 m_pThread->m_bAutoDelete = FALSE;
1250                 m_pThread->ResumeThread();
1251         }
1252 }
1253
1254 void CCommitDlg::OnBnClickedHelp()
1255 {
1256         OnHelp();
1257 }
1258
1259 void CCommitDlg::OnBnClickedShowunversioned()
1260 {
1261         m_tooltips.Pop();       // hide the tooltips
1262         UpdateData();
1263         m_regAddBeforeCommit = m_bShowUnversioned;
1264         if (!m_bBlock)
1265         {
1266                 DWORD dwShow = m_ListCtrl.GetShowFlags();
1267                 if (DWORD(m_regAddBeforeCommit))
1268                         dwShow |= GITSLC_SHOWUNVERSIONED;
1269                 else
1270                         dwShow &= ~GITSLC_SHOWUNVERSIONED;
1271                 if(dwShow & GITSLC_SHOWUNVERSIONED)
1272                 {
1273                         if(m_bWholeProject)
1274                                 m_ListCtrl.GetStatus(NULL,false,false,true);
1275                         else
1276                                 m_ListCtrl.GetStatus(&this->m_pathList,false,false,true);
1277                 }
1278                 m_ListCtrl.Show(dwShow, 0, true, dwShow & ~(CTGitPath::LOGACTIONS_UNVER), true);
1279         }
1280 }
1281
1282 void CCommitDlg::OnStnClickedExternalwarning()
1283 {
1284         m_tooltips.Popup();
1285 }
1286
1287 void CCommitDlg::OnEnChangeLogmessage()
1288 {
1289         UpdateOKButton();
1290 }
1291
1292 LRESULT CCommitDlg::OnGitStatusListCtrlItemCountChanged(WPARAM, LPARAM)
1293 {
1294 #if 0
1295         if ((m_ListCtrl.GetItemCount() == 0)&&(m_ListCtrl.HasUnversionedItems())&&(!m_bShowUnversioned))
1296         {
1297                 if (CMessageBox::Show(*this, IDS_COMMITDLG_NOTHINGTOCOMMITUNVERSIONED, IDS_APPNAME, MB_ICONINFORMATION | MB_YESNO)==IDYES)
1298                 {
1299                         m_bShowUnversioned = TRUE;
1300                         DWORD dwShow = GitSLC_SHOWVERSIONEDBUTNORMALANDEXTERNALSFROMDIFFERENTREPOS | GitSLC_SHOWUNVERSIONED | GitSLC_SHOWLOCKS;
1301                         m_ListCtrl.Show(dwShow);
1302                         UpdateData(FALSE);
1303                 }
1304         }
1305 #endif
1306         return 0;
1307 }
1308
1309 LRESULT CCommitDlg::OnGitStatusListCtrlNeedsRefresh(WPARAM, LPARAM)
1310 {
1311         Refresh();
1312         return 0;
1313 }
1314
1315 LRESULT CCommitDlg::OnFileDropped(WPARAM, LPARAM /*lParam*/)
1316 {
1317 #if 0
1318         BringWindowToTop();
1319         SetForegroundWindow();
1320         SetActiveWindow();
1321         // if multiple files/folders are dropped
1322         // this handler is called for every single item
1323         // separately.
1324         // To avoid creating multiple refresh threads and
1325         // causing crashes, we only add the items to the
1326         // list control and start a timer.
1327         // When the timer expires, we start the refresh thread,
1328         // but only if it isn't already running - otherwise we
1329         // restart the timer.
1330         CTGitPath path;
1331         path.SetFromWin((LPCTSTR)lParam);
1332
1333         // just add all the items we get here.
1334         // if the item is versioned, the add will fail but nothing
1335         // more will happen.
1336         Git Git;
1337         Git.Add(CTGitPathList(path), &m_ProjectProperties, Git_depth_empty, false, true, true);
1338
1339         if (!m_ListCtrl.HasPath(path))
1340         {
1341                 if (m_pathList.AreAllPathsFiles())
1342                 {
1343                         m_pathList.AddPath(path);
1344                         m_pathList.RemoveDuplicates();
1345                         m_updatedPathList.AddPath(path);
1346                         m_updatedPathList.RemoveDuplicates();
1347                 }
1348                 else
1349                 {
1350                         // if the path list contains folders, we have to check whether
1351                         // our just (maybe) added path is a child of one of those. If it is
1352                         // a child of a folder already in the list, we must not add it. Otherwise
1353                         // that path could show up twice in the list.
1354                         bool bHasParentInList = false;
1355                         for (int i=0; i<m_pathList.GetCount(); ++i)
1356                         {
1357                                 if (m_pathList[i].IsAncestorOf(path))
1358                                 {
1359                                         bHasParentInList = true;
1360                                         break;
1361                                 }
1362                         }
1363                         if (!bHasParentInList)
1364                         {
1365                                 m_pathList.AddPath(path);
1366                                 m_pathList.RemoveDuplicates();
1367                                 m_updatedPathList.AddPath(path);
1368                                 m_updatedPathList.RemoveDuplicates();
1369                         }
1370                 }
1371         }
1372
1373         // Always start the timer, since the status of an existing item might have changed
1374         SetTimer(REFRESHTIMER, 200, NULL);
1375         ATLTRACE(_T("Item %s dropped, timer started\n"), path.GetWinPath());
1376 #endif
1377         return 0;
1378 }
1379
1380 LRESULT CCommitDlg::OnAutoListReady(WPARAM, LPARAM)
1381 {
1382         m_cLogMessage.SetAutoCompletionList(m_autolist, '*');
1383         return 0;
1384 }
1385
1386 //////////////////////////////////////////////////////////////////////////
1387 // functions which run in the status thread
1388 //////////////////////////////////////////////////////////////////////////
1389
1390 void CCommitDlg::ParseRegexFile(const CString& sFile, std::map<CString, CString>& mapRegex)
1391 {
1392         CString strLine;
1393         try
1394         {
1395                 CStdioFile file(sFile, CFile::typeText | CFile::modeRead | CFile::shareDenyWrite);
1396                 while (m_bRunThread && file.ReadString(strLine))
1397                 {
1398                         int eqpos = strLine.Find('=');
1399                         CString rgx;
1400                         rgx = strLine.Mid(eqpos+1).Trim();
1401
1402                         int pos = -1;
1403                         while (((pos = strLine.Find(','))>=0)&&(pos < eqpos))
1404                         {
1405                                 mapRegex[strLine.Left(pos)] = rgx;
1406                                 strLine = strLine.Mid(pos+1).Trim();
1407                         }
1408                         mapRegex[strLine.Left(strLine.Find('=')).Trim()] = rgx;
1409                 }
1410                 file.Close();
1411         }
1412         catch (CFileException* pE)
1413         {
1414                 TRACE("CFileException loading auto list regex file\n");
1415                 pE->Delete();
1416                 return;
1417         }
1418 }
1419 void CCommitDlg::GetAutocompletionList()
1420 {
1421         // the auto completion list is made of strings from each selected files.
1422         // the strings used are extracted from the files with regexes found
1423         // in the file "autolist.txt".
1424         // the format of that file is:
1425         // file extensions separated with commas '=' regular expression to use
1426         // example:
1427         // .h, .hpp = (?<=class[\s])\b\w+\b|(\b\w+(?=[\s ]?\(\);))
1428         // .cpp = (?<=[^\s]::)\b\w+\b
1429
1430         std::map<CString, CString> mapRegex;
1431         CString sRegexFile = CPathUtils::GetAppDirectory();
1432         CRegDWORD regtimeout = CRegDWORD(_T("Software\\TortoiseGit\\AutocompleteParseTimeout"), 5);
1433         DWORD timeoutvalue = regtimeout*1000;
1434         sRegexFile += _T("autolist.txt");
1435         if (!m_bRunThread)
1436                 return;
1437         ParseRegexFile(sRegexFile, mapRegex);
1438         SHGetFolderPath(NULL, CSIDL_APPDATA, NULL, SHGFP_TYPE_CURRENT, sRegexFile.GetBuffer(MAX_PATH+1));
1439         sRegexFile.ReleaseBuffer();
1440         sRegexFile += _T("\\TortoiseGit\\autolist.txt");
1441         if (PathFileExists(sRegexFile))
1442         {
1443                 ParseRegexFile(sRegexFile, mapRegex);
1444         }
1445         DWORD starttime = GetTickCount();
1446
1447         // now we have two arrays of strings, where the first array contains all
1448         // file extensions we can use and the second the corresponding regex strings
1449         // to apply to those files.
1450
1451         // the next step is to go over all files shown in the commit dialog
1452         // and scan them for strings we can use
1453         int nListItems = m_ListCtrl.GetItemCount();
1454
1455         for (int i=0; i<nListItems && m_bRunThread; ++i)
1456         {
1457                 // stop parsing after timeout
1458                 if ((!m_bRunThread) || (GetTickCount() - starttime > timeoutvalue))
1459                         return;
1460
1461                 CTGitPath *path = (CTGitPath*)m_ListCtrl.GetItemData(i);
1462
1463                 if(path == NULL)
1464                         continue;
1465
1466                 CString sPartPath =path->GetGitPathString();
1467                 m_autolist.insert(sPartPath);
1468
1469 //              const CGitStatusListCtrl::FileEntry * entry = m_ListCtrl.GetListEntry(i);
1470 //              if (!entry)
1471 //                      continue;
1472
1473                 // add the path parts to the auto completion list too
1474 //              CString sPartPath = entry->GetRelativeGitPath();
1475 //              m_autolist.insert(sPartPath);
1476
1477
1478                 int pos = 0;
1479                 int lastPos = 0;
1480                 while ((pos = sPartPath.Find('/', pos)) >= 0)
1481                 {
1482                         pos++;
1483                         lastPos = pos;
1484                         m_autolist.insert(sPartPath.Mid(pos));
1485                 }
1486
1487                 // Last inserted entry is a file name.
1488                 // Some users prefer to also list file name without extension.
1489                 if (CRegDWORD(_T("Software\\TortoiseGit\\AutocompleteRemovesExtensions"), FALSE))
1490                 {
1491                         int dotPos = sPartPath.ReverseFind('.');
1492                         if ((dotPos >= 0) && (dotPos > lastPos))
1493                                 m_autolist.insert(sPartPath.Mid(lastPos, dotPos - lastPos));
1494                 }
1495 #if 0
1496                 if ((entry->status <= Git_wc_status_normal)||(entry->status == Git_wc_status_ignored))
1497                         continue;
1498
1499                 CString sExt = entry->GetPath().GetFileExtension();
1500                 sExt.MakeLower();
1501                 // find the regex string which corresponds to the file extension
1502                 CString rdata = mapRegex[sExt];
1503                 if (rdata.IsEmpty())
1504                         continue;
1505
1506                 ScanFile(entry->GetPath().GetWinPathString(), rdata);
1507                 if ((entry->textstatus != Git_wc_status_unversioned) &&
1508                         (entry->textstatus != Git_wc_status_none) &&
1509                         (entry->textstatus != Git_wc_status_ignored) &&
1510                         (entry->textstatus != Git_wc_status_added) &&
1511                         (entry->textstatus != Git_wc_status_normal))
1512                 {
1513                         CTGitPath basePath = Git::GetPristinePath(entry->GetPath());
1514                         if (!basePath.IsEmpty())
1515                                 ScanFile(basePath.GetWinPathString(), rdata);
1516                 }
1517 #endif
1518         }
1519         ATLTRACE(_T("Auto completion list loaded in %d msec\n"), GetTickCount() - starttime);
1520 }
1521
1522 void CCommitDlg::ScanFile(const CString& sFilePath, const CString& sRegex)
1523 {
1524         wstring sFileContent;
1525         HANDLE hFile = CreateFile(sFilePath, GENERIC_READ, FILE_SHARE_READ, NULL, OPEN_EXISTING, NULL, NULL);
1526         if (hFile != INVALID_HANDLE_VALUE)
1527         {
1528                 DWORD size = GetFileSize(hFile, NULL);
1529                 if (size > 1000000L)
1530                 {
1531                         // no files bigger than 1 Meg
1532                         CloseHandle(hFile);
1533                         return;
1534                 }
1535                 // allocate memory to hold file contents
1536                 char * buffer = new char[size];
1537                 DWORD readbytes;
1538                 ReadFile(hFile, buffer, size, &readbytes, NULL);
1539                 CloseHandle(hFile);
1540                 int opts = 0;
1541                 IsTextUnicode(buffer, readbytes, &opts);
1542                 if (opts & IS_TEXT_UNICODE_NULL_BYTES)
1543                 {
1544                         delete [] buffer;
1545                         return;
1546                 }
1547                 if (opts & IS_TEXT_UNICODE_UNICODE_MASK)
1548                 {
1549                         sFileContent = wstring((wchar_t*)buffer, readbytes/sizeof(WCHAR));
1550                 }
1551                 if ((opts & IS_TEXT_UNICODE_NOT_UNICODE_MASK)||(opts == 0))
1552                 {
1553                         int ret = MultiByteToWideChar(CP_UTF8, MB_PRECOMPOSED, (LPCSTR)buffer, readbytes, NULL, 0);
1554                         wchar_t * pWideBuf = new wchar_t[ret];
1555                         int ret2 = MultiByteToWideChar(CP_UTF8, MB_PRECOMPOSED, (LPCSTR)buffer, readbytes, pWideBuf, ret);
1556                         if (ret2 == ret)
1557                                 sFileContent = wstring(pWideBuf, ret);
1558                         delete [] pWideBuf;
1559                 }
1560                 delete [] buffer;
1561         }
1562         if (sFileContent.empty()|| !m_bRunThread)
1563         {
1564                 return;
1565         }
1566
1567         try
1568         {
1569                 const tr1::wregex regCheck(sRegex, tr1::regex_constants::icase | tr1::regex_constants::ECMAScript);
1570                 const tr1::wsregex_iterator end;
1571                 wstring s = sFileContent;
1572                 for (tr1::wsregex_iterator it(s.begin(), s.end(), regCheck); it != end; ++it)
1573                 {
1574                         const tr1::wsmatch match = *it;
1575                         for (size_t i=1; i<match.size(); ++i)
1576                         {
1577                                 if (match[i].second-match[i].first)
1578                                 {
1579                                         ATLTRACE(_T("matched keyword : %s\n"), wstring(match[i]).c_str());
1580                                         m_autolist.insert(wstring(match[i]).c_str());
1581                                 }
1582                         }
1583                 }
1584         }
1585         catch (exception) {}
1586 }
1587
1588 // CSciEditContextMenuInterface
1589 void CCommitDlg::InsertMenuItems(CMenu& mPopup, int& nCmd)
1590 {
1591         CString sMenuItemText(MAKEINTRESOURCE(IDS_COMMITDLG_POPUP_PASTEFILELIST));
1592         m_nPopupPasteListCmd = nCmd++;
1593         mPopup.AppendMenu(MF_STRING | MF_ENABLED, m_nPopupPasteListCmd, sMenuItemText);
1594
1595         //CString sMenuItemText(MAKEINTRESOURCE(IDS_COMMITDLG_POPUP_PASTEFILELIST));
1596         if(m_History.GetCount() > 0)
1597         {
1598                 sMenuItemText.LoadString(IDS_COMMITDLG_POPUP_PASTELASTMESSAGE);
1599                 m_nPopupPasteLastMessage = nCmd++;
1600                 mPopup.AppendMenu(MF_STRING | MF_ENABLED, m_nPopupPasteLastMessage, sMenuItemText);
1601
1602                 sMenuItemText.LoadString(IDS_COMMITDLG_POPUP_LOGHISTORY);
1603                 m_nPopupRecentMessage = nCmd++;
1604                 mPopup.AppendMenu(MF_STRING | MF_ENABLED, m_nPopupRecentMessage, sMenuItemText);
1605
1606         }
1607
1608 }
1609
1610 bool CCommitDlg::HandleMenuItemClick(int cmd, CSciEdit * pSciEdit)
1611 {
1612
1613         if (m_bBlock)
1614                 return false;
1615         if (cmd == m_nPopupPasteListCmd)
1616         {
1617                 CString logmsg;
1618                 int nListItems = m_ListCtrl.GetItemCount();
1619                 for (int i=0; i<nListItems; ++i)
1620                 {
1621                         CTGitPath * entry = (CTGitPath*)m_ListCtrl.GetItemData(i);
1622                         if (entry&&entry->m_Checked)
1623                         {
1624                                 CString line;
1625                                 CString status = entry->GetActionName();
1626                                 if(entry->m_Action & CTGitPath::LOGACTIONS_UNVER)
1627                                         status = _T("Add"); // I18N TODO
1628
1629                                 //git_wc_status_kind status = entry->status;
1630                                 WORD langID = (WORD)CRegStdDWORD(_T("Software\\TortoiseGit\\LanguageID"), GetUserDefaultLangID());
1631                                 if (m_ProjectProperties.bFileListInEnglish)
1632                                         langID = 1033;
1633
1634                                 line.Format(_T("%-10s %s\r\n"),status , (LPCTSTR)m_ListCtrl.GetItemText(i,0));
1635                                 logmsg += line;
1636                         }
1637                 }
1638                 pSciEdit->InsertText(logmsg);
1639                 return true;
1640         }
1641
1642         if(cmd == m_nPopupPasteLastMessage)
1643         {
1644                 if(m_History.GetCount() ==0 )
1645                         return false;
1646
1647                 CString logmsg;
1648                 logmsg +=m_History.GetEntry(0);
1649                 pSciEdit->InsertText(logmsg);
1650                 return true;
1651         }
1652
1653         if(cmd == m_nPopupRecentMessage )
1654         {
1655                 OnBnClickedHistory();
1656                 return true;
1657         }
1658         return false;
1659 }
1660
1661 void CCommitDlg::OnTimer(UINT_PTR nIDEvent)
1662 {
1663         switch (nIDEvent)
1664         {
1665         case ENDDIALOGTIMER:
1666                 KillTimer(ENDDIALOGTIMER);
1667                 EndDialog(0);
1668                 break;
1669         case REFRESHTIMER:
1670                 if (m_bThreadRunning)
1671                 {
1672                         SetTimer(REFRESHTIMER, 200, NULL);
1673                         ATLTRACE("Wait some more before refreshing\n");
1674                 }
1675                 else
1676                 {
1677                         KillTimer(REFRESHTIMER);
1678                         ATLTRACE("Refreshing after items dropped\n");
1679                         Refresh();
1680                 }
1681                 break;
1682         }
1683         __super::OnTimer(nIDEvent);
1684 }
1685
1686 void CCommitDlg::OnBnClickedHistory()
1687 {
1688         m_tooltips.Pop();       // hide the tooltips
1689         if (m_pathList.GetCount() == 0)
1690                 return;
1691
1692         CHistoryDlg historyDlg;
1693         historyDlg.SetHistory(m_History);
1694         if (historyDlg.DoModal() != IDOK)
1695                 return;
1696
1697         CString sMsg = historyDlg.GetSelectedText();
1698         if (sMsg != m_cLogMessage.GetText().Left(sMsg.GetLength()))
1699         {
1700                 CString sBugID = m_ProjectProperties.GetBugIDFromLog(sMsg);
1701                 if (!sBugID.IsEmpty())
1702                 {
1703                         SetDlgItemText(IDC_BUGID, sBugID);
1704                 }
1705                 if (m_ProjectProperties.sLogTemplate.Compare(m_cLogMessage.GetText())!=0)
1706                         m_cLogMessage.InsertText(sMsg, !m_cLogMessage.GetText().IsEmpty());
1707                 else
1708                         m_cLogMessage.SetText(sMsg);
1709         }
1710
1711         UpdateOKButton();
1712         GetDlgItem(IDC_LOGMESSAGE)->SetFocus();
1713
1714 }
1715
1716 void CCommitDlg::OnBnClickedBugtraqbutton()
1717 {
1718         m_tooltips.Pop();       // hide the tooltips
1719         CString sMsg = m_cLogMessage.GetText();
1720
1721         if (m_BugTraqProvider == NULL)
1722                 return;
1723
1724         BSTR parameters = m_bugtraq_association.GetParameters().AllocSysString();
1725         BSTR commonRoot = SysAllocString(g_Git.m_CurrentDir);
1726         SAFEARRAY *pathList = SafeArrayCreateVector(VT_BSTR, 0, m_pathList.GetCount());
1727
1728         for (LONG index = 0; index < m_pathList.GetCount(); ++index)
1729                 SafeArrayPutElement(pathList, &index, m_pathList[index].GetGitPathString().AllocSysString());
1730
1731         BSTR originalMessage = sMsg.AllocSysString();
1732         BSTR temp = NULL;
1733 //      m_revProps.clear();
1734
1735         // first try the IBugTraqProvider2 interface
1736         CComPtr<IBugTraqProvider2> pProvider2 = NULL;
1737         HRESULT hr = m_BugTraqProvider.QueryInterface(&pProvider2);
1738         if (SUCCEEDED(hr))
1739         {
1740                 //CString common = m_ListCtrl.GetCommonURL(false).GetGitPathString();
1741                 BSTR repositoryRoot = g_Git.m_CurrentDir.AllocSysString();
1742                 BSTR bugIDOut = NULL;
1743                 GetDlgItemText(IDC_BUGID, m_sBugID);
1744                 BSTR bugID = m_sBugID.AllocSysString();
1745                 SAFEARRAY * revPropNames = NULL;
1746                 SAFEARRAY * revPropValues = NULL;
1747                 if (FAILED(hr = pProvider2->GetCommitMessage2(GetSafeHwnd(), parameters, repositoryRoot, commonRoot, pathList, originalMessage, bugID, &bugIDOut, &revPropNames, &revPropValues, &temp)))
1748                 {
1749                         CString sErr;
1750                         sErr.Format(IDS_ERR_FAILEDISSUETRACKERCOM, m_bugtraq_association.GetProviderName(), _com_error(hr).ErrorMessage());
1751                         CMessageBox::Show(m_hWnd, sErr, _T("TortoiseGit"), MB_ICONERROR);
1752                 }
1753                 else
1754                 {
1755                         if (bugIDOut)
1756                         {
1757                                 m_sBugID = bugIDOut;
1758                                 SysFreeString(bugIDOut);
1759                                 SetDlgItemText(IDC_BUGID, m_sBugID);
1760                         }
1761                         SysFreeString(bugID);
1762                         SysFreeString(repositoryRoot);
1763                         m_cLogMessage.SetText(temp);
1764                         BSTR HUGEP *pbRevNames;
1765                         BSTR HUGEP *pbRevValues;
1766
1767                         HRESULT hr1 = SafeArrayAccessData(revPropNames, (void HUGEP**)&pbRevNames);
1768                         if (SUCCEEDED(hr1))
1769                         {
1770                                 HRESULT hr2 = SafeArrayAccessData(revPropValues, (void HUGEP**)&pbRevValues);
1771                                 if (SUCCEEDED(hr2))
1772                                 {
1773                                         if (revPropNames->rgsabound->cElements == revPropValues->rgsabound->cElements)
1774                                         {
1775                                                 for (ULONG i = 0; i < revPropNames->rgsabound->cElements; i++)
1776                                                 {
1777 //                                                      m_revProps[pbRevNames[i]] = pbRevValues[i];
1778                                                 }
1779                                         }
1780                                         SafeArrayUnaccessData(revPropValues);
1781                                 }
1782                                 SafeArrayUnaccessData(revPropNames);
1783                         }
1784                         if (revPropNames)
1785                                 SafeArrayDestroy(revPropNames);
1786                         if (revPropValues)
1787                                 SafeArrayDestroy(revPropValues);
1788                 }
1789         }
1790         else
1791         {
1792                 // if IBugTraqProvider2 failed, try IBugTraqProvider
1793                 CComPtr<IBugTraqProvider> pProvider = NULL;
1794                 hr = m_BugTraqProvider.QueryInterface(&pProvider);
1795                 if (FAILED(hr))
1796                 {
1797                         CString sErr;
1798                         sErr.Format(IDS_ERR_FAILEDISSUETRACKERCOM, (LPCTSTR)m_bugtraq_association.GetProviderName(), _com_error(hr).ErrorMessage());
1799                         CMessageBox::Show(m_hWnd, sErr, _T("TortoiseGit"), MB_ICONERROR);
1800                         return;
1801                 }
1802
1803                 if (FAILED(hr = pProvider->GetCommitMessage(GetSafeHwnd(), parameters, commonRoot, pathList, originalMessage, &temp)))
1804                 {
1805                         CString sErr;
1806                         sErr.Format(IDS_ERR_FAILEDISSUETRACKERCOM, m_bugtraq_association.GetProviderName(), _com_error(hr).ErrorMessage());
1807                         CMessageBox::Show(m_hWnd, sErr, _T("TortoiseGit"), MB_ICONERROR);
1808                 }
1809                 else
1810                         m_cLogMessage.SetText(temp);
1811         }
1812         m_sLogMessage = m_cLogMessage.GetText();
1813         if (!m_ProjectProperties.sMessage.IsEmpty())
1814         {
1815                 CString sBugID = m_ProjectProperties.FindBugID(m_sLogMessage);
1816                 if (!sBugID.IsEmpty())
1817                 {
1818                         SetDlgItemText(IDC_BUGID, sBugID);
1819                 }
1820         }
1821
1822         m_cLogMessage.SetFocus();
1823
1824         SysFreeString(parameters);
1825         SysFreeString(commonRoot);
1826         SafeArrayDestroy(pathList);
1827         SysFreeString(originalMessage);
1828         SysFreeString(temp);
1829
1830 }
1831
1832 void CCommitDlg::FillPatchView()
1833 {
1834         if(::IsWindow(this->m_patchViewdlg.m_hWnd))
1835         {
1836                 m_patchViewdlg.m_ctrlPatchView.SetText(CString());
1837
1838                 POSITION pos=m_ListCtrl.GetFirstSelectedItemPosition();
1839                 m_patchViewdlg.m_ctrlPatchView.Call(SCI_SETREADONLY, FALSE);
1840                 CString cmd,out;
1841
1842                 while(pos)
1843                 {
1844                         int nSelect = m_ListCtrl.GetNextSelectedItem(pos);
1845                         CTGitPath * p=(CTGitPath*)m_ListCtrl.GetItemData(nSelect);
1846                         if(p && !(p->m_Action&CTGitPath::LOGACTIONS_UNVER) )
1847                         {
1848                                 CString head = _T("HEAD");
1849                                 if(m_bCommitAmend==TRUE && m_bAmendDiffToLastCommit==FALSE)
1850                                         head = _T("HEAD~1");
1851                                 cmd.Format(_T("git.exe diff %s -- \"%s\""), head, p->GetGitPathString());
1852                                 g_Git.Run(cmd, &out, CP_UTF8);
1853                         }
1854                 }
1855
1856                 m_patchViewdlg.m_ctrlPatchView.SetText(out);
1857                 m_patchViewdlg.m_ctrlPatchView.Call(SCI_SETREADONLY, TRUE);
1858                 m_patchViewdlg.m_ctrlPatchView.Call(SCI_GOTOPOS, 0);
1859                 CRect rect;
1860                 m_patchViewdlg.m_ctrlPatchView.GetClientRect(rect);
1861                 m_patchViewdlg.m_ctrlPatchView.Call(SCI_SETSCROLLWIDTH, rect.Width() - 4);
1862         }
1863 }
1864 LRESULT CCommitDlg::OnGitStatusListCtrlItemChanged(WPARAM /*wparam*/, LPARAM /*lparam*/)
1865 {
1866         this->FillPatchView();
1867         return 0;
1868 }
1869
1870
1871 LRESULT CCommitDlg::OnGitStatusListCtrlCheckChanged(WPARAM, LPARAM)
1872 {
1873         UpdateOKButton();
1874         return 0;
1875 }
1876
1877 void CCommitDlg::UpdateOKButton()
1878 {
1879         if (m_bBlock)
1880                 return;
1881
1882         bool bValidLogSize = m_cLogMessage.GetText().GetLength() >= m_ProjectProperties.nMinLogSize && m_cLogMessage.GetText().GetLength() > 0;
1883         bool bAmendOrSelectFilesOrMerge = m_ListCtrl.GetSelected() > 0 || (m_bCommitAmend && m_bAmendDiffToLastCommit) || CTGitPath(g_Git.m_CurrentDir).IsMergeActive();
1884
1885         DialogEnableWindow(IDOK, bValidLogSize && bAmendOrSelectFilesOrMerge);
1886 }
1887
1888 LRESULT CCommitDlg::DefWindowProc(UINT message, WPARAM wParam, LPARAM lParam)
1889 {
1890         switch (message) {
1891         case WM_NOTIFY:
1892                 if (wParam == IDC_SPLITTER)
1893                 {
1894                         SPC_NMHDR* pHdr = (SPC_NMHDR*) lParam;
1895                         DoSize(pHdr->delta);
1896                 }
1897                 break;
1898         }
1899
1900         return __super::DefWindowProc(message, wParam, lParam);
1901 }
1902
1903 void CCommitDlg::SetSplitterRange()
1904 {
1905         if ((m_ListCtrl)&&(m_cLogMessage))
1906         {
1907                 CRect rcTop;
1908                 m_cLogMessage.GetWindowRect(rcTop);
1909                 ScreenToClient(rcTop);
1910                 CRect rcMiddle;
1911                 m_ListCtrl.GetWindowRect(rcMiddle);
1912                 ScreenToClient(rcMiddle);
1913                 if (rcMiddle.Height() && rcMiddle.Width())
1914                         m_wndSplitter.SetRange(rcTop.top+60, rcMiddle.bottom-80);
1915         }
1916 }
1917
1918 void CCommitDlg::DoSize(int delta)
1919 {
1920         RemoveAnchor(IDC_MESSAGEGROUP);
1921         RemoveAnchor(IDC_LOGMESSAGE);
1922         RemoveAnchor(IDC_SPLITTER);
1923         RemoveAnchor(IDC_SIGNOFF);
1924         RemoveAnchor(IDC_COMMIT_AMEND);
1925         RemoveAnchor(IDC_COMMIT_AMENDDIFF);
1926         RemoveAnchor(IDC_COMMIT_SETDATETIME);
1927         RemoveAnchor(IDC_COMMIT_DATEPICKER);
1928         RemoveAnchor(IDC_COMMIT_TIMEPICKER);
1929         RemoveAnchor(IDC_LISTGROUP);
1930         RemoveAnchor(IDC_FILELIST);
1931         RemoveAnchor(IDC_TEXT_INFO);
1932
1933         CSplitterControl::ChangeHeight(&m_cLogMessage, delta, CW_TOPALIGN);
1934         CSplitterControl::ChangeHeight(GetDlgItem(IDC_MESSAGEGROUP), delta, CW_TOPALIGN);
1935         CSplitterControl::ChangeHeight(&m_ListCtrl, -delta, CW_BOTTOMALIGN);
1936         CSplitterControl::ChangeHeight(GetDlgItem(IDC_LISTGROUP), -delta, CW_BOTTOMALIGN);
1937         CSplitterControl::ChangePos(GetDlgItem(IDC_SIGNOFF),0,delta);
1938         CSplitterControl::ChangePos(GetDlgItem(IDC_COMMIT_AMEND),0,delta);
1939         CSplitterControl::ChangePos(GetDlgItem(IDC_COMMIT_AMENDDIFF),0,delta);
1940         CSplitterControl::ChangePos(GetDlgItem(IDC_COMMIT_SETDATETIME),0,delta);
1941         CSplitterControl::ChangePos(GetDlgItem(IDC_COMMIT_DATEPICKER),0,delta);
1942         CSplitterControl::ChangePos(GetDlgItem(IDC_COMMIT_TIMEPICKER),0,delta);
1943         CSplitterControl::ChangePos(GetDlgItem(IDC_TEXT_INFO),0,delta);
1944
1945         AddAnchor(IDC_MESSAGEGROUP, TOP_LEFT, TOP_RIGHT);
1946         AddAnchor(IDC_LOGMESSAGE, TOP_LEFT, TOP_RIGHT);
1947         AddAnchor(IDC_SPLITTER, TOP_LEFT, TOP_RIGHT);
1948         AddAnchor(IDC_LISTGROUP, TOP_LEFT, BOTTOM_RIGHT);
1949         AddAnchor(IDC_FILELIST, TOP_LEFT, BOTTOM_RIGHT);
1950         AddAnchor(IDC_SIGNOFF,TOP_RIGHT);
1951         AddAnchor(IDC_COMMIT_AMEND,TOP_LEFT);
1952         AddAnchor(IDC_COMMIT_AMENDDIFF,TOP_LEFT);
1953         AddAnchor(IDC_COMMIT_SETDATETIME,TOP_LEFT);
1954         AddAnchor(IDC_COMMIT_DATEPICKER,TOP_LEFT);
1955         AddAnchor(IDC_COMMIT_TIMEPICKER,TOP_LEFT);
1956         AddAnchor(IDC_TEXT_INFO,TOP_RIGHT);
1957         ArrangeLayout();
1958         // adjust the minimum size of the dialog to prevent the resizing from
1959         // moving the list control too far down.
1960         CRect rcLogMsg;
1961         m_cLogMessage.GetClientRect(rcLogMsg);
1962         SetMinTrackSize(CSize(m_DlgOrigRect.Width(), m_DlgOrigRect.Height()-m_LogMsgOrigRect.Height()+rcLogMsg.Height()));
1963
1964         SetSplitterRange();
1965         m_cLogMessage.Invalidate();
1966         GetDlgItem(IDC_LOGMESSAGE)->Invalidate();
1967 }
1968
1969 void CCommitDlg::OnSize(UINT nType, int cx, int cy)
1970 {
1971         // first, let the resizing take place
1972         __super::OnSize(nType, cx, cy);
1973
1974         //set range
1975         SetSplitterRange();
1976 }
1977
1978 CString CCommitDlg::GetSignedOffByLine()
1979 {
1980         CString str;
1981
1982         CString username = g_Git.GetUserName();
1983         CString email = g_Git.GetUserEmail();
1984         username.Remove(_T('\n'));
1985         email.Remove(_T('\n'));
1986
1987         str.Format(_T("Signed-off-by: %s <%s>"), username, email);
1988
1989         return str;
1990 }
1991
1992 void CCommitDlg::OnBnClickedSignOff()
1993 {
1994         CString str = GetSignedOffByLine();
1995
1996         if (m_cLogMessage.GetText().Find(str) == -1) {
1997                 m_cLogMessage.SetText(m_cLogMessage.GetText().TrimRight());
1998                 int lastNewline = m_cLogMessage.GetText().ReverseFind(_T('\n'));
1999                 int foundByLine = -1;
2000                 if (lastNewline > 0)
2001                         foundByLine = m_cLogMessage.GetText().Find(_T("-by: "), lastNewline);
2002
2003                 if (foundByLine == -1 || foundByLine < lastNewline)
2004                         str = _T("\r\n") + str;
2005
2006                 m_cLogMessage.SetText(m_cLogMessage.GetText()+_T("\r\n")+str+_T("\r\n"));
2007         }
2008 }
2009
2010 void CCommitDlg::OnBnClickedCommitAmend()
2011 {
2012         this->UpdateData();
2013         if(this->m_bCommitAmend && this->m_AmendStr.IsEmpty())
2014         {
2015                 GitRev rev;
2016                 rev.GetCommit(CString(_T("HEAD")));
2017                 m_AmendStr=rev.GetSubject()+_T("\n")+rev.GetBody();
2018         }
2019
2020         if(this->m_bCommitAmend)
2021         {
2022                 this->m_NoAmendStr=this->m_cLogMessage.GetText();
2023                 m_cLogMessage.SetText(m_AmendStr);
2024                 GetDlgItem(IDC_COMMIT_AMENDDIFF)->ShowWindow(SW_SHOW);
2025         }
2026         else
2027         {
2028                 this->m_AmendStr=this->m_cLogMessage.GetText();
2029                 m_cLogMessage.SetText(m_NoAmendStr);
2030                 GetDlgItem(IDC_COMMIT_AMENDDIFF)->ShowWindow(SW_HIDE);
2031         }
2032
2033         OnBnClickedCommitSetDateTime(); // to update the commit date and time
2034
2035         Refresh();
2036 }
2037
2038 void CCommitDlg::OnBnClickedWholeProject()
2039 {
2040         m_tooltips.Pop();       // hide the tooltips
2041         UpdateData();
2042         m_ListCtrl.Clear();
2043         if (!m_bBlock)
2044         {
2045                 if(m_bWholeProject)
2046                         m_ListCtrl.GetStatus(NULL,true,false,true);
2047                 else
2048                         m_ListCtrl.GetStatus(&this->m_pathList,true,false,true);
2049
2050                 DWORD dwShow = m_ListCtrl.GetShowFlags();
2051                 if (DWORD(m_regAddBeforeCommit))
2052                         dwShow |= GITSLC_SHOWUNVERSIONED;
2053                 else
2054                         dwShow &= ~GITSLC_SHOWUNVERSIONED;
2055
2056                 m_ListCtrl.Show(dwShow, dwShow & ~(CTGitPath::LOGACTIONS_UNVER), true);
2057         }
2058
2059         SetDlgTitle();
2060 }
2061
2062 void CCommitDlg::OnFocusMessage()
2063 {
2064         m_cLogMessage.SetFocus();
2065 }
2066
2067 void CCommitDlg::OnScnUpdateUI(NMHDR *pNMHDR, LRESULT *pResult)
2068 {
2069         UNREFERENCED_PARAMETER(pNMHDR);
2070         int pos=this->m_cLogMessage.Call(SCI_GETCURRENTPOS);
2071         int line=this->m_cLogMessage.Call(SCI_LINEFROMPOSITION,pos);
2072         int column=this->m_cLogMessage.Call(SCI_GETCOLUMN,pos);
2073
2074         CString str;
2075         str.Format(_T("%d/%d"),line+1,column+1);
2076         this->GetDlgItem(IDC_TEXT_INFO)->SetWindowText(str);
2077
2078         if(*pResult)
2079                 *pResult=0;
2080 }
2081 void CCommitDlg::OnStnClickedViewPatch()
2082 {
2083         m_patchViewdlg.m_pProjectProperties = &this->m_ProjectProperties;
2084         m_patchViewdlg.m_ParentCommitDlg = this;
2085         if(!IsWindow(this->m_patchViewdlg.m_hWnd))
2086         {
2087                 BOOL viewPatchEnabled = FALSE;
2088                 m_ProjectProperties.GetBOOLProps(viewPatchEnabled, _T("tgit.commitshowpatch"));
2089                 if (viewPatchEnabled == FALSE)
2090                         g_Git.SetConfigValue(_T("tgit.commitshowpatch"), _T("true"));
2091                 m_patchViewdlg.Create(IDD_PATCH_VIEW,this);
2092                 m_patchViewdlg.m_ctrlPatchView.Call(SCI_SETSCROLLWIDTHTRACKING, TRUE);
2093                 CRect rect;
2094                 this->GetWindowRect(&rect);
2095
2096                 m_patchViewdlg.ShowWindow(SW_SHOW);
2097
2098                 m_patchViewdlg.SetWindowPos(NULL,rect.right,rect.top,rect.Width(),rect.Height(),
2099                                 SWP_NOACTIVATE | SWP_NOOWNERZORDER | SWP_NOZORDER);
2100
2101                 ShowViewPatchText(false);
2102                 FillPatchView();
2103         }
2104         else
2105         {
2106                 g_Git.SetConfigValue(_T("tgit.commitshowpatch"), _T("false"));
2107                 m_patchViewdlg.ShowWindow(SW_HIDE);
2108                 m_patchViewdlg.DestroyWindow();
2109                 ShowViewPatchText(true);
2110         }
2111         this->m_ctrlShowPatch.Invalidate();
2112 }
2113
2114 void CCommitDlg::OnMoving(UINT fwSide, LPRECT pRect)
2115 {
2116         __super::OnMoving(fwSide, pRect);
2117
2118         if (::IsWindow(m_patchViewdlg.m_hWnd))
2119         {
2120                 RECT patchrect;
2121                 m_patchViewdlg.GetWindowRect(&patchrect);
2122                 if (::IsWindow(m_hWnd))
2123                 {
2124                         RECT thisrect;
2125                         GetWindowRect(&thisrect);
2126                         if (patchrect.left == thisrect.right)
2127                         {
2128                                 m_patchViewdlg.SetWindowPos(NULL, patchrect.left - (thisrect.left - pRect->left), patchrect.top - (thisrect.top - pRect->top),
2129                                         0, 0, SWP_NOACTIVATE | SWP_NOOWNERZORDER | SWP_NOSIZE | SWP_NOZORDER);
2130                         }
2131                 }
2132         }
2133
2134 }
2135
2136 void CCommitDlg::OnSizing(UINT fwSide, LPRECT pRect)
2137 {
2138         __super::OnSizing(fwSide, pRect);
2139
2140         if(::IsWindow(this->m_patchViewdlg.m_hWnd))
2141         {
2142                 CRect thisrect, patchrect;
2143                 this->GetWindowRect(thisrect);
2144                 this->m_patchViewdlg.GetWindowRect(patchrect);
2145                 if(thisrect.right==patchrect.left)
2146                 {
2147                         patchrect.left -= (thisrect.right - pRect->right);
2148                         patchrect.right-= (thisrect.right - pRect->right);
2149
2150                         if(     patchrect.bottom == thisrect.bottom)
2151                         {
2152                                 patchrect.bottom -= (thisrect.bottom - pRect->bottom);
2153                         }
2154                         if(     patchrect.top == thisrect.top)
2155                         {
2156                                 patchrect.top -=  thisrect.top-pRect->top;
2157                         }
2158                         m_patchViewdlg.MoveWindow(patchrect);
2159                 }
2160         }
2161 }
2162
2163 void CCommitDlg::OnHdnItemchangedFilelist(NMHDR *pNMHDR, LRESULT *pResult)
2164 {
2165         UNREFERENCED_PARAMETER(pNMHDR);
2166         *pResult = 0;
2167         TRACE("Item Changed\r\n");
2168 }
2169
2170 int CCommitDlg::CheckHeadDetach()
2171 {
2172         CString output;
2173         if(g_Git.GetCurrentBranchFromFile(g_Git.m_CurrentDir,output))
2174         {
2175                 int retval = CMessageBox::Show(NULL, IDS_PROC_COMMIT_DETACHEDWARNING, IDS_APPNAME, MB_YESNOCANCEL | MB_ICONWARNING);
2176                 if(retval == IDYES)
2177                 {
2178                         if (CAppUtils::CreateBranchTag(FALSE, NULL, true) == FALSE)
2179                                 return 1;
2180                 }
2181                 else if (retval == IDCANCEL)
2182                         return 1;
2183         }
2184         return 0;
2185 }
2186
2187 void CCommitDlg::OnBnClickedCommitAmenddiff()
2188 {
2189         UpdateData();
2190         Refresh();
2191 }
2192
2193 void CCommitDlg::OnBnClickedNoautoselectsubmodules()
2194 {
2195         UpdateData();
2196         Refresh();
2197 }
2198
2199 void CCommitDlg::OnBnClickedCommitSetDateTime()
2200 {
2201         UpdateData();
2202
2203         if (m_bSetCommitDateTime)
2204         {
2205                 CTime authordate = CTime::GetCurrentTime();
2206                 if (m_bCommitAmend)
2207                 {
2208                         GitRev headRevision;
2209                         headRevision.GetCommit(_T("HEAD"));
2210                         authordate = headRevision.GetAuthorDate();
2211                 }
2212
2213                 m_CommitDate.SetTime(&authordate);
2214                 m_CommitTime.SetTime(&authordate);
2215
2216                 GetDlgItem(IDC_COMMIT_DATEPICKER)->ShowWindow(SW_SHOW);
2217                 GetDlgItem(IDC_COMMIT_TIMEPICKER)->ShowWindow(SW_SHOW);
2218         }
2219         else
2220         {
2221                 GetDlgItem(IDC_COMMIT_DATEPICKER)->ShowWindow(SW_HIDE);
2222                 GetDlgItem(IDC_COMMIT_TIMEPICKER)->ShowWindow(SW_HIDE);
2223         }
2224 }
2225
2226 void CCommitDlg::OnBnClickedCheckNewBranch()
2227 {
2228         UpdateData();
2229         if (m_bCreateNewBranch)
2230         {
2231                 GetDlgItem(IDC_COMMIT_TO)->ShowWindow(SW_HIDE);
2232                 GetDlgItem(IDC_NEWBRANCH)->ShowWindow(SW_SHOW);
2233         }
2234         else
2235         {
2236                 GetDlgItem(IDC_NEWBRANCH)->ShowWindow(SW_HIDE);
2237                 GetDlgItem(IDC_COMMIT_TO)->ShowWindow(SW_SHOW);
2238         }
2239 }
2240
2241 void CCommitDlg::RestoreFiles(bool doNotAsk)
2242 {
2243         if (m_ListCtrl.m_restorepaths.size() && (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))
2244         {
2245                 for (std::map<CString, CString>::iterator it = m_ListCtrl.m_restorepaths.begin(); it != m_ListCtrl.m_restorepaths.end(); ++it)
2246                         CopyFile(it->second, g_Git.m_CurrentDir + _T("\\") + it->first, FALSE);
2247                 m_ListCtrl.m_restorepaths.clear();
2248         }
2249 }