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