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