src/TortoiseProc/CommitDlg.cpp

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