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