?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Fixed issue #4126: Capitalize the first letter in the Push dialog
[TortoiseGit.git] / src / TortoiseProc / CommitDlg.cpp
blobcfb57f50665688e366328ea65004f2412d43b0eb
1 // TortoiseGit - a Windows shell extension for easy version control
2
3 // Copyright (C) 2003-2014 - TortoiseSVN
4 // Copyright (C) 2008-2023 - 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 "MessageBox.h"
24 #include "AppUtils.h"
25 #include "PathUtils.h"
26 #include "Git.h"
27 #include "HistoryDlg.h"
28 #include "Hooks.h"
29 #include "UnicodeUtils.h"
30 #include "../TGitCache/CacheInterface.h"
31 #include "ProgressDlg.h"
32 #include "ShellUpdater.h"
33 #include "Commands/PushCommand.h"
34 #include "COMError.h"
35 #include "Globals.h"
36 #include "SysProgressDlg.h"
37 #include "MassiveGitTask.h"
38 #include "LogDlg.h"
39 #include "BstrSafeVector.h"
40 #include "StringUtils.h"
41 #include "FileTextLines.h"
42 #include "DPIAware.h"
43
44 #ifdef _DEBUG
45 #define new DEBUG_NEW
46 #undef THIS_FILE
47 static char THIS_FILE[] = __FILE__;
48 #endif
49
50 UINT CCommitDlg::WM_AUTOLISTREADY = RegisterWindowMessage(L"TORTOISEGIT_AUTOLISTREADY_MSG");
51 UINT CCommitDlg::WM_UPDATEOKBUTTON = RegisterWindowMessage(L"TORTOISEGIT_COMMIT_UPDATEOKBUTTON");
52 UINT CCommitDlg::WM_UPDATEDATAFALSE = RegisterWindowMessage(L"TORTOISEGIT_COMMIT_UPDATEDATAFALSE");
53 UINT CCommitDlg::WM_PARTIALSTAGINGREFRESHPATCHVIEW = RegisterWindowMessage(L"TORTOISEGIT_COMMIT_PARTIALSTAGINGREFRESHPATCHVIEW"); // same string in PatchViewDlg.cpp!!!
54
55 IMPLEMENT_DYNAMIC(CCommitDlg, CResizableStandAloneDialog)
56 CCommitDlg::CCommitDlg(CWnd* pParent /*=nullptr*/)
57 : CResizableStandAloneDialog(CCommitDlg::IDD, pParent)
58 , m_bShowUnversioned(FALSE)
59 , m_bWholeProject(FALSE)
60 , m_bWholeProject2(FALSE)
61 , m_bDoNotAutoselectSubmodules(FALSE)
62 , m_bSetCommitDateTime(FALSE)
63 , m_bCreateNewBranch(FALSE)
64 , m_bCommitMessageOnly(FALSE)
65 , m_bSetAuthor(FALSE)
66 , m_bStagingSupport(FALSE)
67 , m_bAmendDiffToLastCommit(FALSE)
68 , m_bCommitAmend(FALSE)
69 {
70 }
71
72 CCommitDlg::~CCommitDlg()
73 {
74 if (m_hAccelOkButton)
75 DestroyAcceleratorTable(m_hAccelOkButton);
76 delete m_pThread;
77 }
78
79 void CCommitDlg::DoDataExchange(CDataExchange* pDX)
80 {
81 CResizableStandAloneDialog::DoDataExchange(pDX);
82 DDX_Control(pDX, IDC_FILELIST, m_ListCtrl);
83 DDX_Control(pDX, IDC_LOGMESSAGE, m_cLogMessage);
84 DDX_Check(pDX, IDC_SHOWUNVERSIONED, m_bShowUnversioned);
85 DDX_Check(pDX, IDC_COMMIT_SETDATETIME, m_bSetCommitDateTime);
86 DDX_Check(pDX, IDC_CHECK_NEWBRANCH, m_bCreateNewBranch);
87 DDX_Text(pDX, IDC_COMMIT_AUTHORDATA, m_sAuthor);
88 DDX_Check(pDX, IDC_WHOLE_PROJECT, m_bWholeProject);
89 DDX_Control(pDX, IDC_SPLITTER, m_wndSplitter);
90 DDX_Check(pDX, IDC_NOAUTOSELECTSUBMODULES, m_bDoNotAutoselectSubmodules);
91 DDX_Check(pDX,IDC_COMMIT_AMEND,m_bCommitAmend);
92 DDX_Check(pDX, IDC_COMMIT_MESSAGEONLY, m_bCommitMessageOnly);
93 DDX_Check(pDX,IDC_COMMIT_AMENDDIFF,m_bAmendDiffToLastCommit);
94 DDX_Check(pDX, IDC_COMMIT_SETAUTHOR, m_bSetAuthor);
95 DDX_Check(pDX, IDC_STAGINGSUPPORT, m_bStagingSupport);
96 DDX_Control(pDX,IDC_VIEW_PATCH,m_ctrlShowPatch);
97 DDX_Control(pDX, IDC_PARTIAL_STAGING, m_ctrlPartialStaging);
98 DDX_Control(pDX, IDC_PARTIAL_UNSTAGING, m_ctrlPartialUnstaging);
99 DDX_Control(pDX, IDC_COMMIT_DATEPICKER, m_CommitDate);
100 DDX_Control(pDX, IDC_COMMIT_TIMEPICKER, m_CommitTime);
101 DDX_Control(pDX, IDC_COMMIT_AS_COMMIT_DATE, m_AsCommitDateCtrl);
102 DDX_Control(pDX, IDC_CHECKALL, m_CheckAll);
103 DDX_Control(pDX, IDC_CHECKNONE, m_CheckNone);
104 DDX_Control(pDX, IDC_CHECKUNVERSIONED, m_CheckUnversioned);
105 DDX_Control(pDX, IDC_CHECKVERSIONED, m_CheckVersioned);
106 DDX_Control(pDX, IDC_CHECKADDED, m_CheckAdded);
107 DDX_Control(pDX, IDC_CHECKDELETED, m_CheckDeleted);
108 DDX_Control(pDX, IDC_CHECKMODIFIED, m_CheckModified);
109 DDX_Control(pDX, IDC_CHECKFILES, m_CheckFiles);
110 DDX_Control(pDX, IDC_CHECKSUBMODULES, m_CheckSubmodules);
111 DDX_Control(pDX, IDOK, m_ctrlOkButton);
112 }
113
114 BEGIN_MESSAGE_MAP(CCommitDlg, CResizableStandAloneDialog)
115 ON_BN_CLICKED(IDC_SHOWUNVERSIONED, OnBnClickedShowunversioned)
116 ON_NOTIFY(SCN_UPDATEUI, IDC_LOGMESSAGE, OnScnUpdateUI)
117 // ON_BN_CLICKED(IDC_HISTORY, OnBnClickedHistory)
118 ON_BN_CLICKED(IDC_BUGTRAQBUTTON, OnBnClickedBugtraqbutton)
119 ON_EN_CHANGE(IDC_LOGMESSAGE, OnEnChangeLogmessage)
120 ON_REGISTERED_MESSAGE(CGitStatusListCtrl::GITSLNM_ITEMCOUNTCHANGED, OnGitStatusListCtrlItemCountChanged)
121 ON_REGISTERED_MESSAGE(CGitStatusListCtrl::GITSLNM_NEEDSREFRESH, OnGitStatusListCtrlNeedsRefresh)
122 ON_REGISTERED_MESSAGE(CGitStatusListCtrl::GITSLNM_ADDFILE, OnFileDropped)
123 ON_REGISTERED_MESSAGE(CGitStatusListCtrl::GITSLNM_CHECKCHANGED, &CCommitDlg::OnGitStatusListCtrlCheckChanged)
124 ON_REGISTERED_MESSAGE(CGitStatusListCtrl::GITSLNM_ITEMCHANGED, &CCommitDlg::OnGitStatusListCtrlItemChanged)
125
126 ON_REGISTERED_MESSAGE(CLinkControl::LK_LINKITEMCLICKED, &CCommitDlg::OnCheck)
127 ON_REGISTERED_MESSAGE(WM_AUTOLISTREADY, OnAutoListReady)
128 ON_REGISTERED_MESSAGE(WM_UPDATEOKBUTTON, OnUpdateOKButton)
129 ON_REGISTERED_MESSAGE(WM_UPDATEDATAFALSE, OnUpdateDataFalse)
130 ON_REGISTERED_MESSAGE(WM_PARTIALSTAGINGREFRESHPATCHVIEW, OnPartialStagingRefreshPatchView)
131 ON_WM_TIMER()
132 ON_WM_SIZE()
133 ON_BN_CLICKED(IDC_SIGNOFF, &CCommitDlg::OnBnClickedSignOff)
134 ON_BN_CLICKED(IDC_COMMIT_AMEND, &CCommitDlg::OnBnClickedCommitAmend)
135 ON_BN_CLICKED(IDC_COMMIT_MESSAGEONLY, &CCommitDlg::OnBnClickedCommitMessageOnly)
136 ON_BN_CLICKED(IDC_WHOLE_PROJECT, &CCommitDlg::OnBnClickedWholeProject)
137 ON_COMMAND(ID_FOCUS_MESSAGE,&CCommitDlg::OnFocusMessage)
138 ON_COMMAND(ID_FOCUS_FILELIST, OnFocusFileList)
139 ON_STN_CLICKED(IDC_VIEW_PATCH, &CCommitDlg::OnStnClickedViewPatch)
140 ON_STN_CLICKED(IDC_PARTIAL_STAGING, &CCommitDlg::OnStnClickedPartialStaging)
141 ON_STN_CLICKED(IDC_PARTIAL_UNSTAGING, &CCommitDlg::OnStnClickedPartialUnstaging)
142 ON_WM_MOVE()
143 ON_WM_MOVING()
144 ON_WM_SIZING()
145 ON_NOTIFY(HDN_ITEMCHANGED, 0, &CCommitDlg::OnHdnItemchangedFilelist)
146 ON_BN_CLICKED(IDC_COMMIT_AMENDDIFF, &CCommitDlg::OnBnClickedCommitAmenddiff)
147 ON_BN_CLICKED(IDC_NOAUTOSELECTSUBMODULES, &CCommitDlg::OnBnClickedNoautoselectsubmodules)
148 ON_BN_CLICKED(IDC_COMMIT_SETDATETIME, &CCommitDlg::OnBnClickedCommitSetDateTime)
149 ON_BN_CLICKED(IDC_COMMIT_AS_COMMIT_DATE, &CCommitDlg::OnBnClickedCommitAsCommitDate)
150 ON_BN_CLICKED(IDC_CHECK_NEWBRANCH, &CCommitDlg::OnBnClickedCheckNewBranch)
151 ON_BN_CLICKED(IDC_COMMIT_SETAUTHOR, &CCommitDlg::OnBnClickedCommitSetauthor)
152 ON_BN_CLICKED(IDC_STAGINGSUPPORT, &CCommitDlg::OnBnClickedStagingSupport)
153 END_MESSAGE_MAP()
154
155 static int GetCommitTemplate(CString &msg)
156 {
157 msg.Empty();
158 CString tplFilename = g_Git.GetConfigValue(L"commit.template");
159 if (tplFilename.IsEmpty())
160 return -1;
161
162 if (tplFilename[0] == L'/')
163 {
164 if (tplFilename.GetLength() >= 3)
165 {
166 // handle "/d/TortoiseGit/tpl.txt" -> "d:/TortoiseGit/tpl.txt"
167 if (tplFilename[2] == L'/')
168 {
169 LPWSTR buf = tplFilename.GetBuffer();
170 buf[0] = buf[1];
171 buf[1] = L':';
172 tplFilename.ReleaseBuffer();
173 }
174 }
175 }
176 else if (CStringUtils::StartsWith(tplFilename, L"~/"))
177 tplFilename = g_Git.GetHomeDirectory() + tplFilename.Mid(static_cast<int>(wcslen(L"~")));
178
179 tplFilename.Replace(L'/', L'\\');
180
181 if (!CGit::LoadTextFile(tplFilename, msg))
182 {
183 MessageBox(nullptr, L"Could not open and load commit.template file: " + tplFilename, L"TortoiseGit", MB_ICONERROR);
184 return -1;
185 }
186 return 0;
187 }
188
189 BOOL CCommitDlg::OnInitDialog()
190 {
191 CResizableStandAloneDialog::OnInitDialog();
192 CAppUtils::MarkWindowAsUnpinnable(m_hWnd);
193
194 GetCommitTemplate(m_sLogTemplate);
195 if (m_sLogMessage.IsEmpty())
196 {
197 if (!m_bForceCommitAmend)
198 m_sLogMessage = m_sLogTemplate;
199
200 CString dotGitPath;
201 GitAdminDir::GetWorktreeAdminDirPath(g_Git.m_CurrentDir, dotGitPath);
202 CGit::LoadTextFile(dotGitPath + L"SQUASH_MSG", m_sLogMessage);
203 CGit::LoadTextFile(dotGitPath + L"MERGE_MSG", m_sLogMessage);
204 }
205
206 m_ProjectProperties.ReadProps();
207
208 if (!RunStartCommitHook())
209 {
210 EndDialog(IDCANCEL);
211 return FALSE;
212 }
213
214 m_regAddBeforeCommit = CRegDWORD(L"Software\\TortoiseGit\\AddBeforeCommit", TRUE);
215 m_bShowUnversioned = m_regAddBeforeCommit;
216
217 CString regPath(g_Git.m_CurrentDir);
218 regPath.Replace(L':', L'_');
219 m_regShowWholeProject = CRegDWORD(L"Software\\TortoiseGit\\TortoiseProc\\ShowWholeProject\\" + regPath, FALSE);
220 m_bWholeProject = m_regShowWholeProject;
221
222 m_History.SetMaxHistoryItems(CRegDWORD(L"Software\\TortoiseGit\\MaxHistoryItems", 25));
223
224 m_regDoNotAutoselectSubmodules = CRegDWORD(L"Software\\TortoiseGit\\DoNotAutoselectSubmodules", FALSE);
225 m_bDoNotAutoselectSubmodules = m_regDoNotAutoselectSubmodules;
226
227 m_hAccel = LoadAccelerators(AfxGetResourceHandle(),MAKEINTRESOURCE(IDR_ACC_COMMITDLG));
228
229 if (m_pathList.IsEmpty())
230 m_bWholeProject2 = true;
231
232 if(this->m_pathList.GetCount() == 1 && m_pathList[0].IsEmpty())
233 m_bWholeProject2 = true;
234
235 SetDlgTitle();
236
237 // git commit accepts only 1970-01-01 to 2099-12-31 regardless timezone
238 COleDateTime minDate(1970, 1, 1, 0, 0, 0), maxDate(2099, 12, 31, 0, 0, 0);
239 m_CommitDate.SetRange(&minDate, &maxDate);
240 if (m_bSetCommitDateTime)
241 {
242 m_CommitDate.SetTime(&m_wantCommitTime);
243 m_CommitTime.SetTime(&m_wantCommitTime);
244 GetDlgItem(IDC_COMMIT_DATEPICKER)->ShowWindow(SW_SHOW);
245 GetDlgItem(IDC_COMMIT_TIMEPICKER)->ShowWindow(SW_SHOW);
246 }
247
248 UpdateData(FALSE);
249
250 m_ListCtrl.Init(GITSLC_COLEXT | GITSLC_COLSTATUS | GITSLC_COLADD | GITSLC_COLDEL, L"CommitDlg", (GITSLC_POPALL ^ (GITSLC_POPCOMMIT | GITSLC_POPSAVEAS | GITSLC_POPPREPAREDIFF)), true, true);
251 m_ListCtrl.SetStatLabel(GetDlgItem(IDC_STATISTICS));
252 m_ListCtrl.SetCancelBool(&m_bCancelled);
253 m_ListCtrl.SetEmptyString(IDS_COMMITDLG_NOTHINGTOCOMMIT);
254 m_ListCtrl.EnableFileDrop();
255 m_ListCtrl.SetBackgroundImage(IDI_COMMIT_BKG);
256
257 //this->DialogEnableWindow(IDC_COMMIT_AMEND,FALSE);
258
259 m_cLogMessage.Init(m_ProjectProperties);
260 m_cLogMessage.SetFont(CAppUtils::GetLogFontName(), CAppUtils::GetLogFontSize());
261 m_cLogMessage.RegisterContextMenuHandler(this);
262 std::map<int, UINT> icons;
263 icons[AUTOCOMPLETE_SPELLING] = IDI_SPELL;
264 icons[AUTOCOMPLETE_FILENAME] = IDI_FILE;
265 icons[AUTOCOMPLETE_PROGRAMCODE] = IDI_CODE;
266 icons[AUTOCOMPLETE_SNIPPET] = IDI_SNIPPET;
267 m_cLogMessage.SetIcon(icons);
268
269 OnEnChangeLogmessage();
270
271 m_tooltips.AddTool(IDC_COMMIT_AMEND,IDS_COMMIT_AMEND_TT);
272 m_tooltips.AddTool(IDC_MERGEACTIVE, IDC_MERGEACTIVE_TT);
273 m_tooltips.AddTool(IDC_COMMIT_MESSAGEONLY, IDS_COMMIT_MESSAGEONLY_TT);
274 m_tooltips.AddTool(IDC_COMMIT_AS_COMMIT_DATE, IDS_COMMIT_AS_COMMIT_DATE_TT);
275
276 CBugTraqAssociations bugtraq_associations;
277 bugtraq_associations.Load(m_ProjectProperties.GetProviderUUID(), m_ProjectProperties.sProviderParams);
278
279 if (bugtraq_associations.FindProvider(g_Git.m_CurrentDir, &m_bugtraq_association))
280 {
281 CComPtr<IBugTraqProvider> pProvider;
282 HRESULT hr = pProvider.CoCreateInstance(m_bugtraq_association.GetProviderClass());
283 if (SUCCEEDED(hr))
284 {
285 m_BugTraqProvider = pProvider;
286 ATL::CComBSTR temp;
287 ATL::CComBSTR parameters(m_bugtraq_association.GetParameters());
288 if (SUCCEEDED(hr = pProvider->GetLinkText(GetSafeHwnd(), parameters, &temp)))
289 {
290 SetDlgItemText(IDC_BUGTRAQBUTTON, temp);
291 GetDlgItem(IDC_BUGTRAQBUTTON)->EnableWindow(TRUE);
292 GetDlgItem(IDC_BUGTRAQBUTTON)->ShowWindow(SW_SHOW);
293 }
294 }
295 }
296 else
297 {
298 GetDlgItem(IDC_BUGTRAQBUTTON)->ShowWindow(SW_HIDE);
299 GetDlgItem(IDC_BUGTRAQBUTTON)->EnableWindow(FALSE);
300 }
301 if (!m_ProjectProperties.sMessage.IsEmpty())
302 {
303 GetDlgItem(IDC_BUGID)->ShowWindow(SW_SHOW);
304 GetDlgItem(IDC_BUGIDLABEL)->ShowWindow(SW_SHOW);
305 if (!m_ProjectProperties.sLabel.IsEmpty())
306 SetDlgItemText(IDC_BUGIDLABEL, m_ProjectProperties.sLabel);
307 GetDlgItem(IDC_BUGID)->SetFocus();
308 CString sBugID = m_ProjectProperties.GetBugIDFromLog(m_sLogMessage);
309 if (!sBugID.IsEmpty())
310 {
311 SetDlgItemText(IDC_BUGID, sBugID);
312 }
313 }
314 else
315 {
316 GetDlgItem(IDC_BUGID)->ShowWindow(SW_HIDE);
317 GetDlgItem(IDC_BUGIDLABEL)->ShowWindow(SW_HIDE);
318 GetDlgItem(IDC_LOGMESSAGE)->SetFocus();
319 }
320
321 if (!m_sLogMessage.IsEmpty())
322 {
323 m_cLogMessage.SetText(m_sLogMessage);
324 m_cLogMessage.Call(SCI_SETCURRENTPOS, 0);
325 m_cLogMessage.Call(SCI_SETSEL, 0, 0);
326 }
327
328 GetWindowText(m_sWindowTitle);
329
330 AdjustControlSize(IDC_SHOWUNVERSIONED);
331 AdjustControlSize(IDC_WHOLE_PROJECT);
332 AdjustControlSize(IDC_CHECK_NEWBRANCH);
333 AdjustControlSize(IDC_COMMIT_AMEND);
334 AdjustControlSize(IDC_COMMIT_MESSAGEONLY);
335 AdjustControlSize(IDC_COMMIT_AMENDDIFF);
336 AdjustControlSize(IDC_COMMIT_SETDATETIME);
337 AdjustControlSize(IDC_COMMIT_SETAUTHOR);
338 AdjustControlSize(IDC_NOAUTOSELECTSUBMODULES);
339 AdjustControlSize(IDC_COMMIT_AS_COMMIT_DATE);
340 AdjustControlSize(IDC_STAGINGSUPPORT);
341
342 // line up all controls and adjust their sizes.
343 #define LINKSPACING 9
344 RECT rc = AdjustControlSize(IDC_SELECTLABEL);
345 rc.right -= 15; // AdjustControlSize() adds 20 pixels for the checkbox/radio button bitmap, but this is a label...
346 rc = AdjustStaticSize(IDC_CHECKALL, rc, LINKSPACING);
347 rc = AdjustStaticSize(IDC_CHECKNONE, rc, LINKSPACING);
348 rc = AdjustStaticSize(IDC_CHECKUNVERSIONED, rc, LINKSPACING);
349 rc = AdjustStaticSize(IDC_CHECKVERSIONED, rc, LINKSPACING);
350 rc = AdjustStaticSize(IDC_CHECKADDED, rc, LINKSPACING);
351 rc = AdjustStaticSize(IDC_CHECKDELETED, rc, LINKSPACING);
352 rc = AdjustStaticSize(IDC_CHECKMODIFIED, rc, LINKSPACING);
353 rc = AdjustStaticSize(IDC_CHECKFILES, rc, LINKSPACING);
354 rc = AdjustStaticSize(IDC_CHECKSUBMODULES, rc, LINKSPACING);
355
356 GetClientRect(m_DlgOrigRect);
357 m_cLogMessage.GetClientRect(m_LogMsgOrigRect);
358
359 AddAnchor(IDC_COMMITLABEL, TOP_LEFT, ANCHOR(94, 0));
360 AddAnchor(IDC_BUGIDLABEL, TOP_RIGHT);
361 AddAnchor(IDC_BUGID, TOP_RIGHT);
362 AddAnchor(IDC_BUGTRAQBUTTON, TOP_RIGHT);
363 AddAnchor(IDC_COMMIT_TO, ANCHOR(6, 0), TOP_RIGHT);
364 AddAnchor(IDC_CHECK_NEWBRANCH, TOP_RIGHT);
365 AddAnchor(IDC_NEWBRANCH, ANCHOR(6,0), TOP_RIGHT);
366 AddAnchor(IDC_MESSAGEGROUP, TOP_LEFT, TOP_RIGHT);
367 // AddAnchor(IDC_HISTORY, TOP_LEFT);
368 AddAnchor(IDC_LOGMESSAGE, TOP_LEFT, TOP_RIGHT);
369 AddAnchor(IDC_SIGNOFF, TOP_RIGHT);
370 AddAnchor(IDC_VIEW_PATCH, BOTTOM_RIGHT);
371 AddAnchor(IDC_PARTIAL_STAGING, BOTTOM_RIGHT);
372 AddAnchor(IDC_PARTIAL_UNSTAGING, BOTTOM_RIGHT);
373 AddAnchor(IDC_LISTGROUP, TOP_LEFT, BOTTOM_RIGHT);
374 AddAnchor(IDC_SPLITTER, TOP_LEFT, TOP_RIGHT);
375 AddAnchor(IDC_FILELIST, TOP_LEFT, BOTTOM_RIGHT);
376 AddAnchor(IDC_SHOWUNVERSIONED, BOTTOM_LEFT);
377 AddAnchor(IDC_STATISTICS, BOTTOM_LEFT, BOTTOM_RIGHT);
378 AddAnchor(IDC_TEXT_INFO, TOP_RIGHT);
379 AddAnchor(IDC_WHOLE_PROJECT, BOTTOM_LEFT);
380 AddAnchor(IDC_NOAUTOSELECTSUBMODULES, BOTTOM_LEFT);
381 AddAnchor(IDC_STAGINGSUPPORT, BOTTOM_LEFT);
382 AddAnchor(IDOK, BOTTOM_RIGHT);
383 AddAnchor(IDCANCEL, BOTTOM_RIGHT);
384 AddAnchor(IDHELP, BOTTOM_RIGHT);
385 AddAnchor(IDC_MERGEACTIVE, BOTTOM_RIGHT);
386 AddAnchor(IDC_COMMIT_AMEND,TOP_LEFT);
387 AddAnchor(IDC_COMMIT_MESSAGEONLY, BOTTOM_LEFT);
388 AddAnchor(IDC_COMMIT_AMENDDIFF,TOP_LEFT);
389 AddAnchor(IDC_COMMIT_SETDATETIME,TOP_LEFT);
390 AddAnchor(IDC_COMMIT_DATEPICKER,TOP_LEFT);
391 AddAnchor(IDC_COMMIT_TIMEPICKER,TOP_LEFT);
392 AddAnchor(IDC_COMMIT_AS_COMMIT_DATE, TOP_LEFT);
393 AddAnchor(IDC_COMMIT_SETAUTHOR, TOP_LEFT);
394 AddAnchor(IDC_COMMIT_AUTHORDATA, TOP_LEFT, TOP_RIGHT);
395
396 AddAnchor(IDC_SELECTLABEL, TOP_LEFT);
397 AddAnchor(IDC_CHECKALL, TOP_LEFT);
398 AddAnchor(IDC_CHECKNONE, TOP_LEFT);
399 AddAnchor(IDC_CHECKUNVERSIONED, TOP_LEFT);
400 AddAnchor(IDC_CHECKVERSIONED, TOP_LEFT);
401 AddAnchor(IDC_CHECKADDED, TOP_LEFT);
402 AddAnchor(IDC_CHECKDELETED, TOP_LEFT);
403 AddAnchor(IDC_CHECKMODIFIED, TOP_LEFT);
404 AddAnchor(IDC_CHECKFILES, TOP_LEFT);
405 AddAnchor(IDC_CHECKSUBMODULES, TOP_LEFT);
406
407 if (GetExplorerHWND())
408 CenterWindow(CWnd::FromHandle(GetExplorerHWND()));
409 EnableSaveRestore(L"CommitDlg");
410 DWORD yPos = CDPIAware::Instance().ScaleY(GetSafeHwnd(), CRegDWORD(L"Software\\TortoiseGit\\TortoiseProc\\ResizableState\\CommitDlgSizer"));
411 RECT rcDlg, rcLogMsg, rcFileList;
412 GetClientRect(&rcDlg);
413 m_cLogMessage.GetWindowRect(&rcLogMsg);
414 ScreenToClient(&rcLogMsg);
415 m_ListCtrl.GetWindowRect(&rcFileList);
416 ScreenToClient(&rcFileList);
417 if (yPos)
418 {
419 RECT rectSplitter;
420 m_wndSplitter.GetWindowRect(&rectSplitter);
421 ScreenToClient(&rectSplitter);
422 const int delta = yPos - rectSplitter.top;
423 if ((rcLogMsg.bottom + delta > rcLogMsg.top) && (rcLogMsg.bottom + delta < rcFileList.bottom - CDPIAware::Instance().ScaleY(GetSafeHwnd(), 30)))
424 {
425 m_wndSplitter.SetWindowPos(nullptr, rectSplitter.left, yPos, 0, 0, SWP_NOSIZE);
426 DoSize(delta);
427 Invalidate();
428 }
429 }
430
431 SetSplitterRange();
432
433 if (m_bForceCommitAmend || m_bCommitAmend)
434 {
435 DialogEnableWindow(IDC_COMMIT_AMENDDIFF, TRUE);
436 GetDlgItem(IDC_COMMIT_AMENDDIFF)->ShowWindow(SW_SHOW);
437 }
438
439 // add all directories to the watcher
440 /*
441 for (int i=0; i<m_pathList.GetCount(); ++i)
442 {
443 if (m_pathList[i].IsDirectory())
444 m_pathwatcher.AddPath(m_pathList[i]);
445 }*/
446
447 this->m_ctrlShowPatch.SetURL(CString());
448 this->m_ctrlPartialStaging.SetURL(CString());
449 this->m_ctrlPartialUnstaging.SetURL(CString());
450 if (g_Git.GetConfigValueBool(L"tgit.commitstagingsupport"))
451 {
452 m_bStagingSupport = true;
453 UpdateData(false);
454 PrepareStagingSupport();
455 }
456 if (g_Git.GetConfigValueBool(L"tgit.commitshowpatch"))
457 {
458 if (m_bStagingSupport)
459 OnStnClickedPartialStaging();
460 else
461 OnStnClickedViewPatch();
462 }
463
464 StartStatusThread();
465 CRegDWORD err = CRegDWORD(L"Software\\TortoiseGit\\ErrorOccurred", FALSE);
466 CRegDWORD historyhint = CRegDWORD(L"Software\\TortoiseGit\\HistoryHintShown", FALSE);
467 if (static_cast<DWORD>(err) != FALSE && static_cast<DWORD>(historyhint) == FALSE)
468 {
469 historyhint = TRUE;
470 // ShowBalloon(IDC_HISTORY, IDS_COMMITDLG_HISTORYHINT_TT, IDI_INFORMATION);
471 }
472 err = FALSE;
473
474 if (CTGitPath(g_Git.m_CurrentDir).IsMergeActive())
475 {
476 DialogEnableWindow(IDC_CHECK_NEWBRANCH, FALSE);
477 m_bCreateNewBranch = FALSE;
478 GetDlgItem(IDC_MERGEACTIVE)->ShowWindow(SW_SHOW);
479 CMessageBox::ShowCheck(GetSafeHwnd(), IDS_COMMIT_MERGE_HINT, IDS_APPNAME, MB_ICONINFORMATION, L"CommitMergeHint", IDS_MSGBOX_DONOTSHOWAGAIN);
480 }
481
482 PrepareOkButton();
483
484 return FALSE; // return TRUE unless you set the focus to a control
485 // EXCEPTION: OCX Property Pages should return FALSE
486 }
487
488 void CCommitDlg::PrepareOkButton()
489 {
490 if (m_bNoPostActions)
491 return;
492 m_regLastAction = CRegDWORD(L"Software\\TortoiseGit\\CommitLastAction", 0);
493 int i = 0;
494 for (auto labelId : { IDS_COMMIT_COMMIT, IDS_COMMIT_RECOMMIT, IDS_COMMIT_COMMITPUSH })
495 {
496 ++i;
497 CString label;
498 label.LoadString(labelId);
499 m_ctrlOkButton.AddEntry(label);
500 wchar_t accellerator = CStringUtils::GetAccellerator(label);
501 if (accellerator == L'\0')
502 continue;
503 ++m_accellerators[accellerator].cnt;
504 if (m_accellerators[accellerator].cnt > 1)
505 m_accellerators[accellerator].id = -1;
506 else
507 m_accellerators[accellerator].id = i - 1;
508 }
509 m_ctrlOkButton.SetCurrentEntry(m_regLastAction);
510 if (m_accellerators.size())
511 {
512 auto lpaccelNew = static_cast<LPACCEL>(LocalAlloc(LPTR, m_accellerators.size() * sizeof(ACCEL)));
513 if (!lpaccelNew)
514 return;
515 SCOPE_EXIT{ LocalFree(lpaccelNew); };
516 i = 0;
517 for (auto& entry : m_accellerators)
518 {
519 lpaccelNew[i].cmd = static_cast<WORD>(WM_USER + 1 + entry.second.id);
520 lpaccelNew[i].fVirt = FVIRTKEY | FALT;
521 lpaccelNew[i].key = entry.first;
522 entry.second.wmid = lpaccelNew[i].cmd;
523 ++i;
524 }
525 m_hAccelOkButton = CreateAcceleratorTable(lpaccelNew, static_cast<int>(m_accellerators.size()));
526 }
527 }
528
529 static bool UpdateIndex(CMassiveGitTask &mgt, CSysProgressDlg &sysProgressDlg, int progress, int maxProgress)
530 {
531 if (mgt.IsListEmpty())
532 return true;
533
534 if (sysProgressDlg.HasUserCancelled())
535 return false;
536
537 if (sysProgressDlg.IsVisible())
538 {
539 sysProgressDlg.SetTitle(IDS_APPNAME);
540 sysProgressDlg.SetLine(1, CString(MAKEINTRESOURCE(IDS_PROC_COMMIT_PREPARECOMMIT)));
541 sysProgressDlg.SetLine(2, CString(MAKEINTRESOURCE(IDS_PROC_COMMIT_UPDATEINDEX)));
542 sysProgressDlg.SetProgress(progress, maxProgress);
543 AfxGetThread()->PumpMessage(); // process messages, in order to avoid freezing
544 }
545
546 BOOL cancel = FALSE;
547 return mgt.Execute(cancel);
548 }
549
550 static void DoPush(HWND hWnd, bool usePushDlg)
551 {
552 CString head;
553 if (g_Git.GetCurrentBranchFromFile(g_Git.m_CurrentDir, head))
554 return;
555 CString remote, remotebranch;
556 g_Git.GetRemotePushBranch(head, remote, remotebranch);
557 if (usePushDlg || remote.IsEmpty() || remotebranch.IsEmpty())
558 {
559 CAppUtils::Push(hWnd);
560 return;
561 }
562
563 CAppUtils::DoPush(hWnd, CAppUtils::IsSSHPutty(), false, false, false, false, false, head, remote, remotebranch, false, 0, L"");
564 }
565
566 void CCommitDlg::OnOK()
567 {
568 if (m_bBlock)
569 return;
570 if (m_bThreadRunning)
571 {
572 m_bCancelled = true;
573 StopStatusThread();
574 }
575 this->UpdateData();
576
577 auto locker(m_ListCtrl.AcquireReadLock());
578
579 if (m_ListCtrl.GetConflictedCount() != 0 && CMessageBox::ShowCheck(GetSafeHwnd(), IDS_PROGRS_CONFLICTSOCCURRED, IDS_APPNAME, 1, IDI_EXCLAMATION, IDS_OKBUTTON, IDS_IGNOREBUTTON, 0, L"CommitWarnOnUnresolved") == 1)
580 {
581 auto pos = m_ListCtrl.GetFirstSelectedItemPosition();
582 while (pos)
583 m_ListCtrl.SetItemState(m_ListCtrl.GetNextSelectedItem(pos), 0, LVIS_SELECTED);
584 const int nListItems = m_ListCtrl.GetItemCount();
585 for (int i = 0; i < nListItems; ++i)
586 {
587 auto entry = m_ListCtrl.GetListEntry(i);
588 if (entry->m_Action & CTGitPath::LOGACTIONS_UNMERGED)
589 {
590 m_ListCtrl.EnsureVisible(i, FALSE);
591 m_ListCtrl.SetItemState(i, LVIS_SELECTED, LVIS_SELECTED);
592 m_ListCtrl.SetFocus();
593 return;
594 }
595 }
596 return;
597 }
598
599 CString newBranch;
600 if (m_bCreateNewBranch)
601 {
602 GetDlgItemText(IDC_NEWBRANCH, newBranch);
603 if (!g_Git.IsBranchNameValid(newBranch))
604 {
605 ShowEditBalloon(IDC_NEWBRANCH, IDS_B_T_NOTEMPTY, IDS_ERR_ERROR, TTI_ERROR);
606 return;
607 }
608 if (g_Git.BranchTagExists(newBranch))
609 {
610 // branch already exists
611 CString msg;
612 msg.LoadString(IDS_B_EXISTS);
613 msg += L' ' + CString(MAKEINTRESOURCE(IDS_B_DELETEORDIFFERENTNAME));
614 ShowEditBalloon(IDC_NEWBRANCH, msg, CString(MAKEINTRESOURCE(IDS_WARN_WARNING)));
615 return;
616 }
617 if (g_Git.BranchTagExists(newBranch, false))
618 {
619 // tag with the same name exists -> shortref is ambiguous
620 if (CMessageBox::Show(m_hWnd, IDS_B_SAMETAGNAMEEXISTS, IDS_APPNAME, 2, IDI_EXCLAMATION, IDS_CONTINUEBUTTON, IDS_ABORTBUTTON) == 2)
621 return;
622 }
623 }
624
625 CString id;
626 GetDlgItemText(IDC_BUGID, id);
627 if (!m_ProjectProperties.CheckBugID(id))
628 {
629 ShowEditBalloon(IDC_BUGID, IDS_COMMITDLG_ONLYNUMBERS, IDS_ERR_ERROR, TTI_ERROR);
630 return;
631 }
632 m_sLogMessage = m_cLogMessage.GetText();
633 if ( m_sLogMessage.IsEmpty() )
634 {
635 // no message entered, go round again
636 CMessageBox::Show(this->m_hWnd, IDS_COMMITDLG_NOMESSAGE, IDS_APPNAME, MB_OK | MB_ICONERROR);
637 return;
638 }
639 if ((m_ProjectProperties.bWarnIfNoIssue) && (id.IsEmpty() && !m_ProjectProperties.HasBugID(m_sLogMessage)))
640 {
641 if (CMessageBox::Show(this->m_hWnd, IDS_COMMITDLG_NOISSUEWARNING, IDS_APPNAME, MB_YESNO | MB_ICONWARNING)!=IDYES)
642 return;
643 }
644 if (!m_sLogTemplate.IsEmpty() && m_sLogTemplate == m_sLogMessage)
645 {
646 if (CMessageBox::ShowCheck(GetSafeHwnd(), IDS_COMMITDLG_NOTEDITEDTEMPLATE, IDS_APPNAME, 2, IDI_WARNING, IDS_PROCEEDBUTTON, IDS_MSGBOX_NO, 0, L"CommitMessageTemplateNotEdited", IDS_MSGBOX_DONOTSHOWAGAIN) != 1)
647 {
648 CMessageBox::RemoveRegistryKey(L"CommitMessageTemplateNotEdited"); // only remember "proceed anyway"
649 return;
650 }
651 }
652
653 if (m_ProjectProperties.bWarnNoSignedOffBy == TRUE && m_cLogMessage.GetText().Find(GetSignedOffByLine()) == -1)
654 {
655 const 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);
656 if (retval == 1)
657 {
658 OnBnClickedSignOff();
659 m_sLogMessage = m_cLogMessage.GetText();
660 }
661 else if (retval == 3)
662 return;
663 }
664
665 if (CAppUtils::MessageContainsConflictHints(GetSafeHwnd(), m_sLogMessage))
666 return;
667
668 CHooks::Instance().SetProjectProperties(g_Git.m_CurrentDir, m_ProjectProperties);
669 if (CHooks::Instance().IsHookPresent(HookType::pre_commit_hook, g_Git.m_CurrentDir))
670 {
671 DWORD exitcode = 0xFFFFFFFF;
672 CString error;
673 CTGitPathList list;
674 m_ListCtrl.WriteCheckedNamesToPathList(list);
675 if (CHooks::Instance().PreCommit(GetSafeHwnd(), g_Git.m_CurrentDir, list, m_sLogMessage, exitcode, error))
676 {
677 if (exitcode)
678 {
679 CString sErrorMsg;
680 sErrorMsg.Format(IDS_HOOK_ERRORMSG, static_cast<LPCWSTR>(error));
681 CTaskDialog taskdlg(sErrorMsg, CString(MAKEINTRESOURCE(IDS_HOOKFAILED_TASK2)), L"TortoiseGit", 0, TDF_ENABLE_HYPERLINKS | TDF_USE_COMMAND_LINKS | TDF_ALLOW_DIALOG_CANCELLATION | TDF_POSITION_RELATIVE_TO_WINDOW | TDF_SIZE_TO_CONTENT);
682 taskdlg.AddCommandControl(101, CString(MAKEINTRESOURCE(IDS_HOOKFAILED_TASK3)));
683 taskdlg.AddCommandControl(102, CString(MAKEINTRESOURCE(IDS_HOOKFAILED_TASK4)));
684 taskdlg.SetDefaultCommandControl(101);
685 taskdlg.SetMainIcon(TD_ERROR_ICON);
686 if (taskdlg.DoModal(GetSafeHwnd()) != 102)
687 return;
688 }
689 }
690 }
691
692 const int nListItems = m_ListCtrl.GetItemCount();
693 for (int i = 0; i < nListItems && !m_bCommitMessageOnly; ++i)
694 {
695 auto entry = m_ListCtrl.GetListEntry(i);
696 if (!entry->m_Checked || !entry->IsDirectory())
697 continue;
698
699 bool dirty = false;
700 if (entry->m_Action & CTGitPath::LOGACTIONS_UNVER)
701 {
702 CGit subgit;
703 subgit.m_IsUseGitDLL = false;
704 subgit.m_CurrentDir = g_Git.CombinePath(entry);
705 CString subcmdout;
706 subgit.Run(L"git.exe status --porcelain", &subcmdout, CP_UTF8);
707 dirty = !subcmdout.IsEmpty();
708 }
709 else
710 {
711 CString cmd, cmdout;
712 cmd.Format(L"git.exe diff -- \"%s\"", entry->GetWinPath());
713 g_Git.Run(cmd, &cmdout, CP_UTF8);
714 dirty = CStringUtils::EndsWith(cmdout, L"-dirty\n");
715 }
716
717 if (dirty)
718 {
719 CString message;
720 message.Format(IDS_COMMITDLG_SUBMODULEDIRTY, static_cast<LPCWSTR>(entry->GetGitPathString()));
721 const int result = CMessageBox::Show(m_hWnd, message, L"TortoiseGit", 1, IDI_QUESTION, CString(MAKEINTRESOURCE(IDS_PROGRS_CMD_COMMIT)), CString(MAKEINTRESOURCE(IDS_MSGBOX_IGNORE)), CString(MAKEINTRESOURCE(IDS_MSGBOX_CANCEL)));
722 if (result == 1)
723 {
724 CString cmdCommit;
725 cmdCommit.Format(L"/command:commit /path:\"%s\\%s\"", static_cast<LPCWSTR>(g_Git.m_CurrentDir), entry->GetWinPath());
726 CAppUtils::RunTortoiseGitProc(cmdCommit);
727 return;
728 }
729 else if (result == 2)
730 continue;
731 else
732 return;
733 }
734 }
735
736 if (!m_bCommitMessageOnly)
737 m_ListCtrl.WriteCheckedNamesToPathList(m_selectedPathList);
738 m_pathwatcher.Stop();
739 InterlockedExchange(&m_bBlock, TRUE);
740
741 int nchecked = 0;
742
743 // these two commands will not be executed if staging support is enabled and neither will everything else inside PrepareIndexForCommitWithoutStagingSupport()
744 CMassiveGitTask mgtReAddAfterCommit(L"add --ignore-errors -f");
745 CMassiveGitTask mgtReDelAfterCommit(L"rm --cached --ignore-unmatch");
746
747 CString cmd;
748 CString out;
749
750 bool bAddSuccess=true;
751 bool bCloseCommitDlg=false;
752
753 CBlockCacheForPath cacheBlock(g_Git.m_CurrentDir);
754
755 if (!m_bStagingSupport)
756 {
757 PrepareIndexForCommitWithoutStagingSupport(nListItems, bAddSuccess, nchecked, mgtReAddAfterCommit, mgtReDelAfterCommit);
758 }
759 else // Staging support is enabled. Simply assume the index is up-to-date and skip all the code dealing with it (inside PrepareIndexForCommitWithoutStagingSupport)
760 {
761 // The code below that deals with the shell icons is also done when staging support is disabled (i.e. inside PrepareIndexForCommitWithoutStagingSupport)
762 for (int j = 0; bAddSuccess && j < nListItems; ++j)
763 CShellUpdater::Instance().AddPathForUpdate(*m_ListCtrl.GetListEntry(j));
764 }
765
766 if (bAddSuccess && m_bCreateNewBranch)
767 {
768 if (g_Git.Run(L"git.exe branch " + newBranch, &out, CP_UTF8))
769 {
770 MessageBox(L"Creating new branch failed:\n" + out, L"TortoiseGit", MB_OK | MB_ICONERROR);
771 bAddSuccess = false;
772 }
773 if (g_Git.Run(L"git.exe checkout " + newBranch + L" --", &out, CP_UTF8))
774 {
775 MessageBox(L"Switching to new branch failed:\n" + out, L"TortoiseGit", MB_OK | MB_ICONERROR);
776 bAddSuccess = false;
777 }
778 }
779
780 if (bAddSuccess && m_bWarnDetachedHead && CheckHeadDetach())
781 bAddSuccess = false;
782
783 UpdateLogMsgByBugId(true);
784
785 // now let the bugtraq plugin check the commit message
786 CComPtr<IBugTraqProvider2> pProvider2;
787 if (m_BugTraqProvider)
788 {
789 HRESULT hr = m_BugTraqProvider.QueryInterface(&pProvider2);
790 if (SUCCEEDED(hr))
791 {
792 ATL::CComBSTR temp;
793 ATL::CComBSTR repositoryRoot(g_Git.m_CurrentDir);
794 ATL::CComBSTR parameters(m_bugtraq_association.GetParameters());
795 ATL::CComBSTR commonRoot(m_pathList.GetCommonRoot().GetDirectory().GetWinPath());
796 ATL::CComBSTR commitMessage(m_sLogMessage);
797 CBstrSafeVector pathList(m_selectedPathList.GetCount());
798
799 for (LONG index = 0; index < m_selectedPathList.GetCount(); ++index)
800 pathList.PutElement(index, m_selectedPathList[index].GetGitPathString());
801
802 if (FAILED(hr = pProvider2->CheckCommit(GetSafeHwnd(), parameters, repositoryRoot, commonRoot, pathList, commitMessage, &temp)))
803 {
804 COMError ce(hr);
805 CString sErr;
806 sErr.FormatMessage(IDS_ERR_FAILEDISSUETRACKERCOM, static_cast<LPCWSTR>(m_bugtraq_association.GetProviderName()), ce.GetMessageAndDescription().c_str());
807 CMessageBox::Show(GetSafeHwnd(), sErr, L"TortoiseGit", MB_ICONERROR);
808 }
809 else
810 {
811 CString sError { static_cast<LPCWSTR>(temp) };
812 if (!sError.IsEmpty())
813 {
814 CMessageBox::Show(GetSafeHwnd(), sError, L"TortoiseGit", MB_ICONERROR);
815 InterlockedExchange(&m_bBlock, FALSE);
816 return;
817 }
818 }
819 }
820 }
821
822 if (m_bCommitMessageOnly || bAddSuccess && (nchecked || m_bStagingSupport || m_bCommitAmend || CTGitPath(g_Git.m_CurrentDir).IsMergeActive()))
823 {
824 bCloseCommitDlg = true;
825
826 CString tempfile=::GetTempFile();
827 if (tempfile.IsEmpty() || CAppUtils::SaveCommitUnicodeFile(tempfile, m_sLogMessage))
828 {
829 CMessageBox::Show(GetSafeHwnd(), L"Could not save commit message", L"TortoiseGit", MB_OK | MB_ICONERROR);
830 InterlockedExchange(&m_bBlock, FALSE);
831 return;
832 }
833
834 CTGitPath path=g_Git.m_CurrentDir;
835
836 const BOOL IsGitSVN = path.GetAdminDirMask() & ITEMIS_GITSVN;
837
838 out.Empty();
839 CString amend;
840 if(this->m_bCommitAmend)
841 amend = L"--amend";
842
843 CString dateTime;
844 if (m_bSetCommitDateTime)
845 {
846 COleDateTime date, time;
847 m_CommitDate.GetTime(date);
848 m_CommitTime.GetTime(time);
849 COleDateTime dateWithTime(date.GetYear(), date.GetMonth(), date.GetDay(), time.GetHour(), time.GetMinute(), time.GetSecond());
850 if (dateWithTime < COleDateTime((time_t)0))
851 {
852 CMessageBox::Show(GetSafeHwnd(), L"Invalid time", L"TortoiseGit", MB_OK | MB_ICONERROR);
853 InterlockedExchange(&m_bBlock, FALSE);
854 return;
855 }
856 if (m_bCommitAmend && m_AsCommitDateCtrl.GetCheck())
857 dateTime = L"--date=\"now\"";
858 else
859 dateTime.Format(L"--date=%sT%s", static_cast<LPCWSTR>(date.Format(L"%Y-%m-%d")), static_cast<LPCWSTR>(time.Format(L"%H:%M:%S")));
860 }
861 CString author;
862 if (m_bSetAuthor)
863 author.Format(L"--author=\"%s\"", static_cast<LPCWSTR>(m_sAuthor));
864 CString allowEmpty = m_bCommitMessageOnly ? L"--allow-empty" : L"";
865 // TODO: make sure notes.amend.rewrite does still work when switching to libgit2
866 cmd.Format(L"git.exe commit %s %s %s %s -F \"%s\"", static_cast<LPCWSTR>(author), static_cast<LPCWSTR>(dateTime), static_cast<LPCWSTR>(amend), static_cast<LPCWSTR>(allowEmpty), static_cast<LPCWSTR>(tempfile));
867
868 CCommitProgressDlg progress;
869 progress.m_bBufferAll=true; // improve show speed when there are many file added.
870 progress.m_GitCmd=cmd;
871 progress.m_bShowCommand = FALSE; // don't show the commit command
872 progress.m_PreText = out; // show any output already generated in log window
873 if (m_ctrlOkButton.GetCurrentEntry() > 0)
874 progress.m_AutoClose = GitProgressAutoClose::AUTOCLOSE_IF_NO_ERRORS;
875
876 progress.m_PostCmdCallback = [&](DWORD status, PostCmdList& postCmdList)
877 {
878 if (status || m_bNoPostActions || m_bAutoClose)
879 return;
880
881 if (IsGitSVN)
882 postCmdList.emplace_back(IDI_COMMIT, IDS_MENUSVNDCOMMIT, [&] { m_PostCmd = Git_PostCommit_Cmd::DCommit; });
883
884 postCmdList.emplace_back(IDI_PUSH, IDS_MENUPUSH, [&] { m_PostCmd = Git_PostCommit_Cmd::Push; });
885 postCmdList.emplace_back(IDI_PULL, IDS_MENUPULL, [&] { m_PostCmd = Git_PostCommit_Cmd::Pull; });
886 postCmdList.emplace_back(IDI_COMMIT, IDS_PROC_COMMIT_RECOMMIT, [&] { m_PostCmd = Git_PostCommit_Cmd::ReCommit; });
887 postCmdList.emplace_back(IDI_TAG, IDS_MENUTAG, [&] { m_PostCmd = Git_PostCommit_Cmd::CreateTag; });
888 };
889
890 m_PostCmd = Git_PostCommit_Cmd::Nothing;
891 progress.DoModal();
892
893 if (!m_bNoPostActions)
894 m_regLastAction = static_cast<int>(m_ctrlOkButton.GetCurrentEntry());
895 if (m_ctrlOkButton.GetCurrentEntry() == 1)
896 m_PostCmd = Git_PostCommit_Cmd::ReCommit;
897
898 ::DeleteFile(tempfile);
899
900 if (m_BugTraqProvider && progress.m_GitStatus == 0)
901 {
902 CComPtr<IBugTraqProvider2> pProvider;
903 HRESULT hr = m_BugTraqProvider.QueryInterface(&pProvider);
904 if (SUCCEEDED(hr))
905 {
906 ATL::CComBSTR commonRoot(g_Git.m_CurrentDir);
907 CBstrSafeVector pathList(m_selectedPathList.GetCount());
908
909 for (LONG index = 0; index < m_selectedPathList.GetCount(); ++index)
910 pathList.PutElement(index, m_selectedPathList[index].GetGitPathString());
911
912 ATL::CComBSTR logMessage(m_sLogMessage);
913
914 CGitHash hash;
915 if (g_Git.GetHash(hash, L"HEAD"))
916 MessageBox(g_Git.GetGitLastErr(L"Could not get HEAD hash after committing."), L"TortoiseGit", MB_ICONERROR);
917 LONG version = g_Git.Hash2int(hash);
918
919 ATL::CComBSTR temp;
920 if (FAILED(hr = pProvider->OnCommitFinished(GetSafeHwnd(),
921 commonRoot,
922 pathList,
923 logMessage,
924 version,
925 &temp)))
926 {
927 CString sErr { static_cast<LPCWSTR>(temp) };
928 if (!sErr.IsEmpty())
929 CMessageBox::Show(GetSafeHwnd(), sErr, L"TortoiseGit", MB_OK | MB_ICONERROR);
930 else
931 {
932 COMError ce(hr);
933 sErr.FormatMessage(IDS_ERR_FAILEDISSUETRACKERCOM, ce.GetSource().c_str(), ce.GetMessageAndDescription().c_str());
934 CMessageBox::Show(GetSafeHwnd(), sErr, L"TortoiseGit", MB_OK | MB_ICONERROR);
935 }
936 }
937 }
938 }
939 RestoreFiles(progress.m_GitStatus == 0, false);
940 if (!m_bStagingSupport && static_cast<DWORD>(CRegStdDWORD(L"Software\\TortoiseGit\\ReaddUnselectedAddedFilesAfterCommit", TRUE)) == TRUE)
941 {
942 BOOL cancel = FALSE;
943 mgtReAddAfterCommit.Execute(cancel);
944 mgtReDelAfterCommit.Execute(cancel);
945 }
946
947 if (!progress.m_GitStatus)
948 {
949 DWORD exitcode = 0xFFFFFFFF;
950 CString error;
951 CHooks::Instance().SetProjectProperties(g_Git.m_CurrentDir, m_ProjectProperties);
952 if (CHooks::Instance().PostCommit(GetSafeHwnd(), g_Git.m_CurrentDir, amend.IsEmpty(), exitcode, error))
953 {
954 if (exitcode)
955 {
956 CString temp;
957 temp.Format(IDS_ERR_HOOKFAILED, static_cast<LPCWSTR>(error));
958 MessageBox(temp, L"TortoiseGit", MB_ICONERROR);
959 bCloseCommitDlg = false;
960 }
961 }
962 CTGitPathList* pList;
963 if (m_bWholeProject || m_bWholeProject2)
964 pList = nullptr;
965 else
966 pList = &m_pathList;
967 if (!m_ListCtrl.KeepChangeList())
968 {
969 m_ListCtrl.PruneChangelists(pList);
970 m_ListCtrl.SaveChangelists();
971 }
972 }
973
974 if (progress.m_GitStatus || m_PostCmd == Git_PostCommit_Cmd::ReCommit)
975 {
976 bCloseCommitDlg = false;
977 if (m_bCreateNewBranch)
978 {
979 SetDlgItemText(IDC_COMMIT_TO, g_Git.GetCurrentBranch()); // issue #3625
980 GetDlgItem(IDC_NEWBRANCH)->ShowWindow(SW_HIDE);
981 GetDlgItem(IDC_COMMIT_TO)->ShowWindow(SW_SHOW);
982 }
983 m_bCreateNewBranch = FALSE;
984 if (!progress.m_GitStatus && m_PostCmd == Git_PostCommit_Cmd::ReCommit)
985 {
986 if (!m_sLogMessage.IsEmpty())
987 {
988 ReloadHistoryEntries();
989 m_History.AddEntry(m_sLogMessage);
990 m_History.Save();
991 }
992 if (m_bCommitAmend && !m_NoAmendStr.IsEmpty() && (m_sLogTemplate.Compare(m_NoAmendStr) != 0))
993 {
994 ReloadHistoryEntries();
995 m_History.AddEntry(m_NoAmendStr);
996 m_History.Save();
997 }
998
999 GetCommitTemplate(m_sLogTemplate);
1000 m_sLogMessage = m_sLogTemplate;
1001 m_cLogMessage.SetText(m_sLogMessage);
1002 m_cLogMessage.ClearUndoBuffer();
1003 m_bCommitMessageOnly = FALSE;
1004 m_ListCtrl.EnableWindow(TRUE);
1005 m_ListCtrl.Clear();
1006 if (!RunStartCommitHook())
1007 bCloseCommitDlg = true;
1008 }
1009
1010 if (!progress.m_GitStatus)
1011 {
1012 m_AmendStr.Empty();
1013 m_bCommitAmend = FALSE;
1014 GetDlgItem(IDC_COMMIT_AMENDDIFF)->ShowWindow(SW_HIDE);
1015 DialogEnableWindow(IDC_COMMIT_AMENDDIFF, FALSE);
1016 m_bSetCommitDateTime = FALSE;
1017 m_AsCommitDateCtrl.ShowWindow(SW_HIDE);
1018 m_AsCommitDateCtrl.SetCheck(FALSE);
1019 m_AsCommitDateCtrl.EnableWindow(FALSE);
1020 GetDlgItem(IDC_COMMIT_DATEPICKER)->ShowWindow(SW_HIDE);
1021 GetDlgItem(IDC_COMMIT_TIMEPICKER)->ShowWindow(SW_HIDE);
1022 m_bSetAuthor = FALSE;
1023 m_sAuthor.Format(L"%s <%s>", static_cast<LPCWSTR>(g_Git.GetUserName()), static_cast<LPCWSTR>(g_Git.GetUserEmail()));
1024 GetDlgItem(IDC_COMMIT_AUTHORDATA)->SendMessage(EM_SETREADONLY, TRUE);
1025 }
1026
1027 UpdateData(FALSE);
1028 }
1029 }
1030 else if(bAddSuccess)
1031 {
1032 CMessageBox::Show(this->m_hWnd, IDS_ERROR_NOTHING_COMMIT, IDS_COMMIT_FINISH, MB_OK | MB_ICONINFORMATION);
1033 bCloseCommitDlg=false;
1034 }
1035
1036 UpdateData();
1037 m_regAddBeforeCommit = m_bShowUnversioned;
1038 m_regDoNotAutoselectSubmodules = m_bDoNotAutoselectSubmodules;
1039 InterlockedExchange(&m_bBlock, FALSE);
1040
1041 if (!m_sLogMessage.IsEmpty())
1042 {
1043 ReloadHistoryEntries();
1044 m_History.AddEntry(m_sLogMessage);
1045 m_History.Save();
1046 }
1047 if (m_bCommitAmend && !m_NoAmendStr.IsEmpty() && (m_sLogTemplate.Compare(m_NoAmendStr) != 0))
1048 {
1049 ReloadHistoryEntries();
1050 m_History.AddEntry(m_NoAmendStr);
1051 m_History.Save();
1052 }
1053
1054 SaveSplitterPos();
1055
1056 if (bCloseCommitDlg)
1057 {
1058 if (m_ctrlOkButton.GetCurrentEntry() == 2)
1059 DoPush(GetSafeHwnd(), !!m_bCommitAmend);
1060 CResizableStandAloneDialog::OnOK();
1061 }
1062 else if (m_PostCmd == Git_PostCommit_Cmd::ReCommit)
1063 {
1064 m_bDoNotStoreLastSelectedLine = true;
1065 this->Refresh();
1066 this->BringWindowToTop();
1067 }
1068
1069 CShellUpdater::Instance().Flush();
1070 }
1071
1072 void CCommitDlg::PrepareIndexForCommitWithoutStagingSupport(int nListItems, bool& bAddSuccess, int& nchecked, CMassiveGitTask& mgtReAddAfterCommit, CMassiveGitTask& mgtReDelAfterCommit)
1073 {
1074 //first add all the unversioned files the user selected
1075 //and check if all versioned files are selected
1076
1077 CSysProgressDlg sysProgressDlg;
1078 if (nListItems >= 25)
1079 {
1080 sysProgressDlg.SetTitle(CString(MAKEINTRESOURCE(IDS_PROC_COMMIT_PREPARECOMMIT)));
1081 sysProgressDlg.SetLine(1, CString(MAKEINTRESOURCE(IDS_PROC_COMMIT_UPDATEINDEX)));
1082 sysProgressDlg.SetTime(true);
1083 sysProgressDlg.SetShowProgressBar(true);
1084 sysProgressDlg.ShowModal(this, true);
1085 }
1086
1087 ULONGLONG currentTicks = GetTickCount64();
1088
1089 if (g_Git.UsingLibGit2(CGit::GIT_CMD_COMMIT_UPDATE_INDEX))
1090 {
1091 bAddSuccess = false;
1092 do
1093 {
1094 CAutoRepository repository(g_Git.GetGitRepository());
1095 if (!repository)
1096 {
1097 CMessageBox::Show(GetSafeHwnd(), CGit::GetLibGit2LastErr(L"Could not open repository."), L"TortoiseGit", MB_OK | MB_ICONERROR);
1098 break;
1099 }
1100
1101 CGitHash revHash;
1102 CString revRef = L"HEAD";
1103 if (m_bCommitAmend && !m_bAmendDiffToLastCommit)
1104 revRef = L"HEAD~1";
1105 if (CGit::GetHash(repository, revHash, revRef))
1106 {
1107 MessageBox(g_Git.GetLibGit2LastErr(L"Could not get HEAD hash after committing."), L"TortoiseGit", MB_ICONERROR);
1108 break;
1109 }
1110
1111 CAutoCommit commit;
1112 if (!revHash.IsEmpty() && git_commit_lookup(commit.GetPointer(), repository, revHash))
1113 {
1114 CMessageBox::Show(GetSafeHwnd(), CGit::GetLibGit2LastErr(L"Could not get last commit."), L"TortoiseGit", MB_OK | MB_ICONERROR);
1115 break;
1116 }
1117
1118 CAutoTree tree;
1119 if (!revHash.IsEmpty() && git_commit_tree(tree.GetPointer(), commit))
1120 {
1121 CMessageBox::Show(GetSafeHwnd(), CGit::GetLibGit2LastErr(L"Could not read tree of commit."), L"TortoiseGit", MB_OK | MB_ICONERROR);
1122 break;
1123 }
1124
1125 CAutoIndex index;
1126 if (git_repository_index(index.GetPointer(), repository))
1127 {
1128 CMessageBox::Show(GetSafeHwnd(), CGit::GetLibGit2LastErr(L"Could not get the repository index."), L"TortoiseGit", MB_OK | MB_ICONERROR);
1129 break;
1130 }
1131
1132 CAutoIndex indexOld;
1133 if (!revHash.IsEmpty() && (git_index_new(indexOld.GetPointer()) || git_index_read_tree(indexOld, tree)))
1134 {
1135 CMessageBox::Show(GetSafeHwnd(), CGit::GetLibGit2LastErr(L"Could not read the tree into the index."), L"TortoiseGit", MB_OK | MB_ICONERROR);
1136 break;
1137 }
1138
1139 bAddSuccess = true;
1140
1141 for (int j = 0; j < nListItems; ++j)
1142 {
1143 auto entry = m_ListCtrl.GetListEntry(j);
1144
1145 if (sysProgressDlg.IsVisible())
1146 {
1147 if (GetTickCount64() - currentTicks > 1000UL || j == nListItems - 1 || j == 0)
1148 {
1149 sysProgressDlg.SetLine(2, entry->GetGitPathString(), true);
1150 sysProgressDlg.SetProgress(j, nListItems);
1151 AfxGetThread()->PumpMessage(); // process messages, in order to avoid freezing; do not call this too often: this takes time!
1152 currentTicks = GetTickCount64();
1153 }
1154 }
1155
1156 CStringA filePathA = CUnicodeUtils::GetUTF8(entry->GetGitPathString()).TrimRight(L'/');
1157
1158 if (entry->m_Checked && !m_bCommitMessageOnly)
1159 {
1160 if (entry->m_Action & CTGitPath::LOGACTIONS_DELETED)
1161 git_index_remove_bypath(index, filePathA); // ignore error
1162 else
1163 {
1164 if (git_index_add_bypath(index, filePathA))
1165 {
1166 bAddSuccess = false;
1167 CMessageBox::Show(GetSafeHwnd(), CGit::GetLibGit2LastErr(L"Could not add \"" + entry->GetGitPathString() + L"\" to index."), L"TortoiseGit", MB_OK | MB_ICONERROR);
1168 break;
1169 }
1170 }
1171
1172 if ((entry->m_Action & CTGitPath::LOGACTIONS_REPLACED) && !entry->GetGitOldPathString().IsEmpty())
1173 git_index_remove_bypath(index, CUnicodeUtils::GetUTF8(entry->GetGitOldPathString())); // ignore error
1174
1175 ++nchecked;
1176 }
1177 else
1178 {
1179 if (entry->m_Action & CTGitPath::LOGACTIONS_ADDED || entry->m_Action & CTGitPath::LOGACTIONS_REPLACED)
1180 {
1181 git_index_remove_bypath(index, filePathA); // ignore error
1182 mgtReAddAfterCommit.AddFile(*entry);
1183
1184 if (entry->m_Action & CTGitPath::LOGACTIONS_REPLACED && !entry->GetGitOldPathString().IsEmpty())
1185 {
1186 const git_index_entry* oldIndexEntry = nullptr;
1187 if ((oldIndexEntry = git_index_get_bypath(indexOld, CUnicodeUtils::GetUTF8(entry->GetGitOldPathString()), 0)) == nullptr || git_index_add(index, oldIndexEntry))
1188 {
1189 bAddSuccess = false;
1190 CMessageBox::Show(GetSafeHwnd(), CGit::GetLibGit2LastErr(L"Could not reset \"" + entry->GetGitOldPathString() + L"\" to old index entry."), L"TortoiseGit", MB_OK | MB_ICONERROR);
1191 break;
1192 }
1193 mgtReDelAfterCommit.AddFile(entry->GetGitOldPathString());
1194 }
1195 }
1196 else if (!(entry->m_Action & CTGitPath::LOGACTIONS_UNVER))
1197 {
1198 const git_index_entry* oldIndexEntry = nullptr;
1199 if ((oldIndexEntry = git_index_get_bypath(indexOld, filePathA, 0)) == nullptr || git_index_add(index, oldIndexEntry))
1200 {
1201 bAddSuccess = false;
1202 CMessageBox::Show(GetSafeHwnd(), CGit::GetLibGit2LastErr(L"Could not reset \"" + entry->GetGitPathString() + L"\" to old index entry."), L"TortoiseGit", MB_OK | MB_ICONERROR);
1203 break;
1204 }
1205 if (entry->m_Action & CTGitPath::LOGACTIONS_DELETED && !(entry->m_Action & CTGitPath::LOGACTIONS_MISSING))
1206 mgtReDelAfterCommit.AddFile(entry->GetGitPathString());
1207 }
1208 }
1209
1210 if (sysProgressDlg.HasUserCancelled())
1211 {
1212 bAddSuccess = false;
1213 break;
1214 }
1215 }
1216 if (bAddSuccess && git_index_write(index))
1217 bAddSuccess = false;
1218
1219 for (int j = 0; bAddSuccess && j < nListItems; ++j)
1220 CShellUpdater::Instance().AddPathForUpdate(*m_ListCtrl.GetListEntry(j));
1221 } while (0);
1222 }
1223 else
1224 {
1225 // ***************************************************
1226 // ATTENTION: Similar code in RebaseDlg.cpp!!!
1227 // ***************************************************
1228 CMassiveGitTask mgtAdd(L"add -f");
1229 CMassiveGitTask mgtUpdateIndexForceRemove(L"update-index --force-remove");
1230 CMassiveGitTask mgtUpdateIndex(L"update-index");
1231 CMassiveGitTask mgtRm(L"rm --ignore-unmatch");
1232 CMassiveGitTask mgtRmFCache(L"rm -f --cache");
1233 CString resetCmd = L"reset";
1234 if (m_bCommitAmend && !m_bAmendDiffToLastCommit)
1235 resetCmd += L" HEAD~1";
1236 CMassiveGitTask mgtReset(resetCmd, TRUE, true);
1237 for (int j = 0; j < nListItems; ++j)
1238 {
1239 auto entry = m_ListCtrl.GetListEntry(j);
1240
1241 if (entry->m_Checked && !m_bCommitMessageOnly)
1242 {
1243 if ((entry->m_Action & CTGitPath::LOGACTIONS_UNVER) || (entry->IsDirectory() && !(entry->m_Action & CTGitPath::LOGACTIONS_DELETED)))
1244 mgtAdd.AddFile(entry->GetGitPathString());
1245 else if (entry->m_Action & CTGitPath::LOGACTIONS_DELETED)
1246 mgtUpdateIndexForceRemove.AddFile(entry->GetGitPathString());
1247 else
1248 mgtUpdateIndex.AddFile(entry->GetGitPathString());
1249
1250 if ((entry->m_Action & CTGitPath::LOGACTIONS_REPLACED) && !entry->GetGitOldPathString().IsEmpty())
1251 mgtRm.AddFile(entry->GetGitOldPathString());
1252
1253 ++nchecked;
1254 }
1255 else
1256 {
1257 if (entry->m_Action & CTGitPath::LOGACTIONS_ADDED || entry->m_Action & CTGitPath::LOGACTIONS_REPLACED)
1258 { //To init git repository, there are not HEAD, so we can use git reset command
1259 mgtRmFCache.AddFile(entry->GetGitPathString());
1260 mgtReAddAfterCommit.AddFile(*entry);
1261
1262 if (entry->m_Action & CTGitPath::LOGACTIONS_REPLACED && !entry->GetGitOldPathString().IsEmpty())
1263 {
1264 mgtReset.AddFile(entry->GetGitOldPathString());
1265 mgtReDelAfterCommit.AddFile(entry->GetGitOldPathString());
1266 }
1267 }
1268 else if (!(entry->m_Action & CTGitPath::LOGACTIONS_UNVER))
1269 {
1270 mgtReset.AddFile(entry->GetGitPathString());
1271 if (entry->m_Action & CTGitPath::LOGACTIONS_DELETED && !(entry->m_Action & CTGitPath::LOGACTIONS_MISSING))
1272 mgtReDelAfterCommit.AddFile(entry->GetGitPathString());
1273 }
1274 }
1275
1276 if (sysProgressDlg.HasUserCancelled())
1277 {
1278 bAddSuccess = false;
1279 break;
1280 }
1281 }
1282
1283 CMassiveGitTask tasks[] = { mgtAdd, mgtUpdateIndexForceRemove, mgtUpdateIndex, mgtRm, mgtRmFCache, mgtReset };
1284 int progress = 0, maxProgress = 0;
1285 for (int j = 0; j < _countof(tasks); ++j)
1286 maxProgress += tasks[j].GetListCount();
1287 for (int j = 0; j < _countof(tasks); ++j)
1288 bAddSuccess = bAddSuccess && UpdateIndex(tasks[j], sysProgressDlg, progress += tasks[j].GetListCount(), maxProgress);
1289
1290 if (sysProgressDlg.HasUserCancelled())
1291 bAddSuccess = false;
1292
1293 for (int j = 0; bAddSuccess && j < nListItems; ++j)
1294 CShellUpdater::Instance().AddPathForUpdate(*m_ListCtrl.GetListEntry(j));
1295 }
1296
1297 if (sysProgressDlg.HasUserCancelled())
1298 bAddSuccess = false;
1299
1300 sysProgressDlg.Stop();
1301 }
1302
1303 void CCommitDlg::SaveSplitterPos()
1304 {
1305 if (!IsIconic())
1306 {
1307 CRegDWORD regPos(L"Software\\TortoiseGit\\TortoiseProc\\ResizableState\\CommitDlgSizer");
1308 RECT rectSplitter;
1309 m_wndSplitter.GetWindowRect(&rectSplitter);
1310 ScreenToClient(&rectSplitter);
1311 regPos = CDPIAware::Instance().UnscaleY(GetSafeHwnd(), rectSplitter.top);
1312 }
1313 }
1314
1315 UINT CCommitDlg::StatusThreadEntry(LPVOID pVoid)
1316 {
1317 return static_cast<CCommitDlg*>(pVoid)->StatusThread();
1318 }
1319
1320 void CCommitDlg::ReloadHistoryEntries()
1321 {
1322 CString reg;
1323 reg.Format(L"Software\\TortoiseGit\\History\\commit%s", static_cast<LPCWSTR>(m_ListCtrl.m_sUUID));
1324 reg.Replace(L':', L'_');
1325 m_History.Load(reg, L"logmsgs");
1326 }
1327
1328 UINT CCommitDlg::StatusThread()
1329 {
1330 //get the status of all selected file/folders recursively
1331 //and show the ones which have to be committed to the user
1332 //in a list control.
1333 m_pathwatcher.Stop();
1334
1335 m_bCancelled = false;
1336
1337 DialogEnableWindow(IDOK, false);
1338 DialogEnableWindow(IDC_SHOWUNVERSIONED, false);
1339 DialogEnableWindow(IDC_WHOLE_PROJECT, false);
1340 DialogEnableWindow(IDC_NOAUTOSELECTSUBMODULES, false);
1341 DialogEnableWindow(IDC_COMMIT_AMEND, FALSE);
1342 DialogEnableWindow(IDC_COMMIT_AMENDDIFF, FALSE);
1343 DialogEnableWindow(IDC_STAGINGSUPPORT, false);
1344 GetDlgItem(IDC_COMMIT_AUTHORDATA)->SendMessage(EM_SETREADONLY, TRUE);
1345 // read the list of recent log entries before querying the WC for status
1346 // -> the user may select one and modify / update it while we are crawling the WC
1347
1348 DialogEnableWindow(IDC_CHECKALL, false);
1349 DialogEnableWindow(IDC_CHECKNONE, false);
1350 DialogEnableWindow(IDC_CHECKUNVERSIONED, false);
1351 DialogEnableWindow(IDC_CHECKVERSIONED, false);
1352 DialogEnableWindow(IDC_CHECKADDED, false);
1353 DialogEnableWindow(IDC_CHECKDELETED, false);
1354 DialogEnableWindow(IDC_CHECKMODIFIED, false);
1355 DialogEnableWindow(IDC_CHECKFILES, false);
1356 DialogEnableWindow(IDC_CHECKSUBMODULES, false);
1357
1358 g_Git.RefreshGitIndex();
1359
1360 CTGitPath repoRoot { g_Git.m_CurrentDir };
1361 if (repoRoot.IsCherryPickActive())
1362 {
1363 GetDlgItem(IDC_COMMIT_AMENDDIFF)->ShowWindow(SW_HIDE);
1364 DialogEnableWindow(IDC_COMMIT_AMENDDIFF, FALSE);
1365 m_bCommitAmend = FALSE;
1366 SendMessage(WM_UPDATEDATAFALSE);
1367 }
1368
1369 if (!m_bDoNotStoreLastSelectedLine)
1370 m_ListCtrl.StoreScrollPos();
1371 // Initialise the list control with the status of the files/folders below us
1372 m_ListCtrl.Clear();
1373 BOOL success;
1374 CTGitPathList *pList;
1375 m_ListCtrl.m_amend = (m_bCommitAmend==TRUE || m_bForceCommitAmend) && (m_bAmendDiffToLastCommit==FALSE);
1376 m_ListCtrl.m_bIncludedStaged = true;
1377 m_ListCtrl.m_bDoNotAutoselectSubmodules = (m_bDoNotAutoselectSubmodules == TRUE);
1378
1379 if(m_bWholeProject || m_bWholeProject2)
1380 pList = nullptr;
1381 else
1382 pList = &m_pathList;
1383
1384 success = m_ListCtrl.GetStatus(pList, false, false, false, false, false, m_bStagingSupport);
1385
1386 //m_ListCtrl.UpdateFileList(git_revnum_t(GIT_REV_ZERO));
1387 if(this->m_bShowUnversioned)
1388 m_ListCtrl.UpdateFileList(CGitStatusListCtrl::FILELIST_UNVER, true, pList, m_bStagingSupport);
1389
1390 m_ListCtrl.CheckIfChangelistsArePresent(false);
1391
1392 DWORD dwShow = GITSLC_SHOWVERSIONEDBUTNORMALANDEXTERNALSFROMDIFFERENTREPOS | GITSLC_SHOWINCHANGELIST | GITSLC_SHOWDIRECTFILES;
1393 dwShow |= DWORD(m_regAddBeforeCommit) ? GITSLC_SHOWUNVERSIONED : 0;
1394 if (success)
1395 {
1396 /*if (!m_checkedPathList.IsEmpty())
1397 m_ListCtrl.Show(dwShow, m_checkedPathList);
1398 else*/
1399 {
1400 DWORD dwCheck = m_bSelectFilesForCommit ? dwShow : 0;
1401 dwCheck &=~(CTGitPath::LOGACTIONS_UNVER); //don't check unversion file default.
1402 m_ListCtrl.Show(dwShow, dwCheck);
1403 }
1404
1405 SetDlgItemText(IDC_COMMIT_TO, g_Git.GetCurrentBranch());
1406 m_tooltips.AddTool(GetDlgItem(IDC_STATISTICS), m_ListCtrl.GetStatisticsString());
1407 if (m_ListCtrl.GetItemCount() != 0 && m_ListCtrl.GetTopIndex() == 0 && (m_bDoNotStoreLastSelectedLine || CRegDWORD(L"Software\\TortoiseGit\\RememberFileListPosition", TRUE) != TRUE))
1408 m_ListCtrl.SetItemState(0, LVIS_SELECTED, LVIS_SELECTED);
1409 }
1410 if (!success)
1411 {
1412 if (!m_ListCtrl.GetLastErrorMessage().IsEmpty())
1413 m_ListCtrl.SetEmptyString(m_ListCtrl.GetLastErrorMessage());
1414 m_ListCtrl.Show(dwShow);
1415 }
1416 m_bDoNotStoreLastSelectedLine = false;
1417
1418 if (m_ListCtrl.GetItemCount() == 0 && m_ListCtrl.HasUnversionedItems() && !repoRoot.IsMergeActive())
1419 {
1420 CString temp;
1421 temp.LoadString(IDS_COMMITDLG_NOTHINGTOCOMMITUNVERSIONED);
1422 if (CMessageBox::ShowCheck(GetSafeHwnd(), temp, L"TortoiseGit", MB_ICONINFORMATION | MB_YESNO, L"NothingToCommitShowUnversioned", nullptr) == IDYES)
1423 {
1424 m_bShowUnversioned = TRUE;
1425 GetDlgItem(IDC_SHOWUNVERSIONED)->SendMessage(BM_SETCHECK, BST_CHECKED);
1426 dwShow = static_cast<DWORD>(GITSLC_SHOWVERSIONEDBUTNORMALANDEXTERNALSFROMDIFFERENTREPOS | GITSLC_SHOWUNVERSIONED);
1427 m_ListCtrl.UpdateFileList(CGitStatusListCtrl::FILELIST_UNVER);
1428 m_ListCtrl.Show(dwShow,dwShow&(~CTGitPath::LOGACTIONS_UNVER));
1429 }
1430 }
1431
1432 GetDlgItem(IDC_MERGEACTIVE)->ShowWindow(repoRoot.IsMergeActive() ? SW_SHOW : SW_HIDE);
1433
1434 SetDlgTitle();
1435
1436 // we don't have to block the commit dialog while we fetch the
1437 // auto completion list.
1438 m_pathwatcher.ClearChangedPaths();
1439 InterlockedExchange(&m_bBlock, FALSE);
1440 std::map<CString, int> autolist;
1441 if (static_cast<DWORD>(CRegDWORD(L"Software\\TortoiseGit\\Autocompletion", TRUE)) == TRUE)
1442 {
1443 m_ListCtrl.BusyCursor(true);
1444 GetAutocompletionList(autolist);
1445 m_ListCtrl.BusyCursor(false);
1446 }
1447 SendMessage(WM_UPDATEOKBUTTON);
1448 m_ListCtrl.Invalidate();
1449 if (m_bRunThread)
1450 {
1451 DialogEnableWindow(IDC_SHOWUNVERSIONED, true);
1452 DialogEnableWindow(IDC_WHOLE_PROJECT, !m_bWholeProject2);
1453 DialogEnableWindow(IDC_NOAUTOSELECTSUBMODULES, true);
1454 DialogEnableWindow(IDC_STAGINGSUPPORT, true);
1455
1456 // activate amend checkbox (if necessary)
1457 if (g_Git.IsInitRepos())
1458 {
1459 m_bCommitAmend = FALSE;
1460 SendMessage(WM_UPDATEDATAFALSE);
1461 }
1462 else
1463 {
1464 if (m_bForceCommitAmend)
1465 {
1466 m_bCommitAmend = TRUE;
1467 SendMessage(WM_UPDATEDATAFALSE);
1468 }
1469 else
1470 GetDlgItem(IDC_COMMIT_AMEND)->EnableWindow(!repoRoot.IsCherryPickActive());
1471
1472 CGitHash hash;
1473 if (g_Git.GetHash(hash, L"HEAD"))
1474 {
1475 MessageBox(g_Git.GetGitLastErr(L"Could not get HEAD hash."), L"TortoiseGit", MB_ICONERROR);
1476 }
1477 if (!hash.IsEmpty())
1478 {
1479 GitRev headRevision;
1480 if (headRevision.GetParentFromHash(hash))
1481 MessageBox(headRevision.GetLastErr(), L"TortoiseGit", MB_ICONERROR);
1482 // do not allow to show diff to "last" revision if it has more that one parent
1483 if (headRevision.ParentsCount() < 1)
1484 {
1485 m_bAmendDiffToLastCommit = TRUE;
1486 SendMessage(WM_UPDATEDATAFALSE);
1487 }
1488 else
1489 GetDlgItem(IDC_COMMIT_AMENDDIFF)->EnableWindow(TRUE);
1490 }
1491 }
1492
1493 if (m_bSetAuthor)
1494 GetDlgItem(IDC_COMMIT_AUTHORDATA)->SendMessage(EM_SETREADONLY, FALSE);
1495 else
1496 {
1497 m_sAuthor.Format(L"%s <%s>", static_cast<LPCWSTR>(g_Git.GetUserName()), static_cast<LPCWSTR>(g_Git.GetUserEmail()));
1498 if (m_bCommitAmend)
1499 {
1500 GitRev headRevision;
1501 if (headRevision.GetCommit(L"HEAD"))
1502 MessageBox(headRevision.GetLastErr(), L"TortoiseGit", MB_ICONERROR);
1503 else
1504 m_sAuthor.Format(L"%s <%s>", static_cast<LPCWSTR>(headRevision.GetAuthorName()), static_cast<LPCWSTR>(headRevision.GetAuthorEmail()));
1505 }
1506 SendMessage(WM_UPDATEDATAFALSE);
1507 }
1508
1509 UpdateCheckLinks();
1510
1511 // we have the list, now signal the main thread about it
1512 SendMessage(WM_AUTOLISTREADY, 0, reinterpret_cast<LPARAM>(&autolist)); // only send the message if the thread wasn't told to quit!
1513 }
1514
1515 InterlockedExchange(&m_bRunThread, FALSE);
1516 InterlockedExchange(&m_bThreadRunning, FALSE);
1517 // force the cursor to normal
1518 RefreshCursor();
1519
1520 return 0;
1521 }
1522
1523 void CCommitDlg::SetDlgTitle()
1524 {
1525 if (m_sTitle.IsEmpty())
1526 GetWindowText(m_sTitle);
1527
1528 if (m_bWholeProject || m_bWholeProject2)
1529 CAppUtils::SetWindowTitle(m_hWnd, g_Git.m_CurrentDir, m_sTitle);
1530 else
1531 {
1532 if (m_pathList.GetCount() == 1)
1533 CAppUtils::SetWindowTitle(m_hWnd, g_Git.CombinePath(m_pathList[0].GetUIPathString()), m_sTitle);
1534 else
1535 CAppUtils::SetWindowTitle(m_hWnd, g_Git.CombinePath(m_ListCtrl.GetCommonDirectory(false)), m_sTitle);
1536 }
1537 }
1538
1539 void CCommitDlg::OnCancel()
1540 {
1541 UpdateData();
1542 m_sLogMessage = m_cLogMessage.GetText();
1543 UpdateLogMsgByBugId(false);
1544
1545 bool hasChangedMessage;
1546 if (m_bCommitAmend)
1547 hasChangedMessage = (m_AmendStr.Compare(m_sLogMessage) != 0) && !m_sLogMessage.IsEmpty();
1548 else
1549 hasChangedMessage = (m_sLogTemplate.Compare(m_sLogMessage) != 0) && !m_sLogMessage.IsEmpty();
1550
1551 CString tmp;
1552 tmp.LoadString(IDS_REALLYCANCEL);
1553 tmp.AppendChar(L'\n');
1554 tmp.AppendChar(L'\n');
1555 tmp.Append(CString(MAKEINTRESOURCE(IDS_HINTLASTMESSAGES)));
1556 CString dontaskagain;
1557 dontaskagain.LoadString(IDS_MSGBOX_DONOTSHOWAGAIN);
1558 BOOL dontaskagainchecked = FALSE;
1559 if ((hasChangedMessage || m_ListCtrl.GetItemCount() > 0) && CMessageBox::ShowCheck(GetSafeHwnd(), tmp, L"TortoiseGit", MB_ICONQUESTION | MB_DEFBUTTON2 | MB_YESNO, L"CommitAskBeforeCancel", dontaskagain, &dontaskagainchecked) == IDNO)
1560 {
1561 if (dontaskagainchecked)
1562 CMessageBox::SetRegistryValue(L"CommitAskBeforeCancel", IDYES);
1563 return;
1564 }
1565
1566 m_bCancelled = true;
1567 m_pathwatcher.Stop();
1568
1569 if (m_bThreadRunning)
1570 StopStatusThread();
1571 if (!RestoreFiles())
1572 return;
1573 if (hasChangedMessage)
1574 {
1575 ReloadHistoryEntries();
1576 m_History.AddEntry(m_sLogMessage);
1577 m_History.Save();
1578 }
1579 if (m_bCommitAmend && !m_NoAmendStr.IsEmpty() && (m_sLogTemplate.Compare(m_NoAmendStr) != 0))
1580 {
1581 ReloadHistoryEntries();
1582 m_History.AddEntry(m_NoAmendStr);
1583 m_History.Save();
1584 }
1585 SaveSplitterPos();
1586 CResizableStandAloneDialog::OnCancel();
1587 }
1588
1589 void CCommitDlg::UpdateLogMsgByBugId(bool compareExistingBugID)
1590 {
1591 GetDlgItemText(IDC_BUGID, m_sBugID);
1592 m_sBugID.Trim();
1593 if (m_sBugID.IsEmpty())
1594 return;
1595 if (compareExistingBugID)
1596 {
1597 CString sExistingBugID = m_ProjectProperties.FindBugID(m_sLogMessage);
1598 sExistingBugID.Trim();
1599 if (!m_sBugID.Compare(sExistingBugID)) // not match
1600 return;
1601 }
1602
1603 m_sBugID.Replace(L", ", L",");
1604 m_sBugID.Replace(L" ,", L",");
1605 CString sBugID = m_ProjectProperties.sMessage;
1606 sBugID.Replace(L"%BUGID%", m_sBugID);
1607 if (m_ProjectProperties.bAppend)
1608 m_sLogMessage += L'\n' + sBugID + L'\n';
1609 else
1610 m_sLogMessage = sBugID + L'\n' + m_sLogMessage;
1611 }
1612
1613 BOOL CCommitDlg::PreTranslateMessage(MSG* pMsg)
1614 {
1615 if (m_hAccel)
1616 {
1617 const int ret = TranslateAccelerator(m_hWnd, m_hAccel, pMsg);
1618 if (ret)
1619 return TRUE;
1620 }
1621 if (m_hAccelOkButton && GetDlgItem(IDOK)->IsWindowEnabled() && TranslateAccelerator(m_hWnd, m_hAccelOkButton, pMsg))
1622 return TRUE;
1623
1624 if (pMsg->message == WM_KEYDOWN)
1625 {
1626 switch (pMsg->wParam)
1627 {
1628 case VK_F5:
1629 {
1630 if (m_bBlock)
1631 return CResizableStandAloneDialog::PreTranslateMessage(pMsg);
1632 Refresh();
1633 }
1634 break;
1635 case VK_RETURN:
1636 {
1637 if (GetAsyncKeyState(VK_CONTROL)&0x8000)
1638 {
1639 if ( GetDlgItem(IDOK)->IsWindowEnabled() )
1640 PostMessage(WM_COMMAND, IDOK);
1641 return TRUE;
1642 }
1643 if ( GetFocus()==GetDlgItem(IDC_BUGID) )
1644 {
1645 // Pressing RETURN in the bug id control
1646 // moves the focus to the message
1647 GetDlgItem(IDC_LOGMESSAGE)->SetFocus();
1648 return TRUE;
1649 }
1650 }
1651 break;
1652 }
1653 }
1654
1655 return CResizableStandAloneDialog::PreTranslateMessage(pMsg);
1656 }
1657
1658 void CCommitDlg::Refresh()
1659 {
1660 if (m_bThreadRunning)
1661 return;
1662
1663 StartStatusThread();
1664 }
1665
1666 void CCommitDlg::StartStatusThread()
1667 {
1668 if (InterlockedExchange(&m_bBlock, TRUE) != FALSE)
1669 return;
1670
1671 delete m_pThread;
1672
1673 m_pThread = AfxBeginThread(StatusThreadEntry, this, THREAD_PRIORITY_NORMAL, 0, CREATE_SUSPENDED);
1674 if (!m_pThread)
1675 {
1676 CMessageBox::Show(GetSafeHwnd(), IDS_ERR_THREADSTARTFAILED, IDS_APPNAME, MB_OK | MB_ICONERROR);
1677 InterlockedExchange(&m_bBlock, FALSE);
1678 return;
1679 }
1680 InterlockedExchange(&m_bThreadRunning, TRUE);// so the main thread knows that this thread is still running
1681 InterlockedExchange(&m_bRunThread, TRUE); // if this is set to FALSE, the thread should stop
1682 m_pThread->m_bAutoDelete = FALSE;
1683 m_pThread->ResumeThread();
1684 }
1685
1686 void CCommitDlg::StopStatusThread()
1687 {
1688 InterlockedExchange(&m_bRunThread, FALSE);
1689 WaitForSingleObject(m_pThread->m_hThread, 5000);
1690 if (!m_bThreadRunning)
1691 return;
1692
1693 // we gave the thread a chance to quit. Since the thread didn't
1694 // listen to us we have to kill it.
1695 g_Git.KillRelatedThreads(m_pThread);
1696 InterlockedExchange(&m_bThreadRunning, FALSE);
1697 }
1698
1699 void CCommitDlg::OnBnClickedShowunversioned()
1700 {
1701 m_tooltips.Pop(); // hide the tooltips
1702 UpdateData();
1703 m_regAddBeforeCommit = m_bShowUnversioned;
1704 if (!m_bBlock)
1705 {
1706 DWORD dwShow = m_ListCtrl.GetShowFlags();
1707 if (DWORD(m_regAddBeforeCommit))
1708 dwShow |= GITSLC_SHOWUNVERSIONED;
1709 else
1710 dwShow &= ~GITSLC_SHOWUNVERSIONED;
1711 if(dwShow & GITSLC_SHOWUNVERSIONED)
1712 {
1713 if (m_bWholeProject || m_bWholeProject2)
1714 m_ListCtrl.GetStatus(nullptr, false, false, true);
1715 else
1716 m_ListCtrl.GetStatus(&this->m_pathList,false,false,true);
1717 }
1718 m_ListCtrl.StoreScrollPos();
1719 m_ListCtrl.Show(dwShow, 0, true, dwShow & ~(CTGitPath::LOGACTIONS_UNVER), true);
1720 UpdateCheckLinks();
1721 }
1722 }
1723
1724 void CCommitDlg::OnEnChangeLogmessage()
1725 {
1726 SendMessage(WM_UPDATEOKBUTTON);
1727 }
1728
1729 LRESULT CCommitDlg::OnGitStatusListCtrlItemCountChanged(WPARAM, LPARAM)
1730 {
1731 #if 0
1732 if ((m_ListCtrl.GetItemCount() == 0)&&(m_ListCtrl.HasUnversionedItems())&&(!m_bShowUnversioned))
1733 {
1734 if (CMessageBox::Show(*this, IDS_COMMITDLG_NOTHINGTOCOMMITUNVERSIONED, IDS_APPNAME, MB_ICONINFORMATION | MB_YESNO)==IDYES)
1735 {
1736 m_bShowUnversioned = TRUE;
1737 DWORD dwShow = GitSLC_SHOWVERSIONEDBUTNORMALANDEXTERNALSFROMDIFFERENTREPOS | GitSLC_SHOWUNVERSIONED;
1738 m_ListCtrl.Show(dwShow);
1739 UpdateData(FALSE);
1740 }
1741 }
1742 #endif
1743 return 0;
1744 }
1745
1746 LRESULT CCommitDlg::OnGitStatusListCtrlNeedsRefresh(WPARAM, LPARAM)
1747 {
1748 Refresh();
1749 return 0;
1750 }
1751
1752 LRESULT CCommitDlg::OnFileDropped(WPARAM, LPARAM lParam)
1753 {
1754 BringWindowToTop();
1755 SetForegroundWindow();
1756 SetActiveWindow();
1757 // if multiple files/folders are dropped
1758 // this handler is called for every single item
1759 // separately.
1760 // To avoid creating multiple refresh threads and
1761 // causing crashes, we only add the items to the
1762 // list control and start a timer.
1763 // When the timer expires, we start the refresh thread,
1764 // but only if it isn't already running - otherwise we
1765 // restart the timer.
1766 CTGitPath path;
1767 path.SetFromWin(reinterpret_cast<LPCWSTR>(lParam));
1768
1769 // check whether the dropped file belongs to the very same repository
1770 CString projectDir;
1771 if (!path.HasAdminDir(&projectDir) || !CPathUtils::ArePathStringsEqual(g_Git.m_CurrentDir, projectDir))
1772 return 0;
1773
1774 // just add all the items we get here.
1775 // if the item is versioned, the add will fail but nothing
1776 // more will happen.
1777 CString cmd;
1778 cmd.Format(L"git.exe add -- \"%s\"", static_cast<LPCWSTR>(path.GetWinPathString()));
1779 g_Git.Run(cmd, nullptr, CP_UTF8);
1780
1781 if (!m_ListCtrl.HasPath(path))
1782 {
1783 if (m_pathList.AreAllPathsFiles())
1784 {
1785 m_pathList.AddPath(path);
1786 m_pathList.RemoveDuplicates();
1787 }
1788 else
1789 {
1790 // if the path list contains folders, we have to check whether
1791 // our just (maybe) added path is a child of one of those. If it is
1792 // a child of a folder already in the list, we must not add it. Otherwise
1793 // that path could show up twice in the list.
1794 if (!m_pathList.IsAnyAncestorOf(path))
1795 {
1796 m_pathList.AddPath(path);
1797 m_pathList.RemoveDuplicates();
1798 }
1799 }
1800 }
1801 m_ListCtrl.ResetChecked(path);
1802
1803 // Always start the timer, since the status of an existing item might have changed
1804 SetTimer(REFRESHTIMER, 200, nullptr);
1805 CTraceToOutputDebugString::Instance()(_T(__FUNCTION__) L": Item %s dropped, timer started\n", path.GetWinPath());
1806 return 0;
1807 }
1808
1809 LRESULT CCommitDlg::OnAutoListReady(WPARAM, LPARAM lparam)
1810 {
1811 m_cLogMessage.SetAutoCompletionList(std::move(*reinterpret_cast<std::map<CString, int>*>(lparam)), '*');
1812 return 0;
1813 }
1814
1815 //////////////////////////////////////////////////////////////////////////
1816 // functions which run in the status thread
1817 //////////////////////////////////////////////////////////////////////////
1818
1819 void CCommitDlg::ParseRegexFile(const CString& sFile, std::map<CString, CString>& mapRegex)
1820 {
1821 CString strLine;
1822 try
1823 {
1824 CStdioFile file(sFile, CFile::typeText | CFile::modeRead | CFile::shareDenyWrite);
1825 while (m_bRunThread && file.ReadString(strLine))
1826 {
1827 if (strLine.IsEmpty())
1828 continue;
1829 if (strLine[0] == L'#')
1830 continue;
1831 const int eqpos = strLine.Find('=');
1832 CString rgx;
1833 rgx = strLine.Mid(eqpos+1).Trim();
1834
1835 int pos = -1;
1836 while (((pos = strLine.Find(','))>=0)&&(pos < eqpos))
1837 {
1838 mapRegex[strLine.Left(pos)] = rgx;
1839 strLine = strLine.Mid(pos+1).Trim();
1840 }
1841 mapRegex[strLine.Left(strLine.Find('=')).Trim()] = rgx;
1842 }
1843 file.Close();
1844 }
1845 catch (CFileException* pE)
1846 {
1847 CTraceToOutputDebugString::Instance()(__FUNCTION__ ": CFileException loading auto list regex file\n");
1848 pE->Delete();
1849 }
1850 }
1851
1852 void CCommitDlg::ParseSnippetFile(const CString& sFile, std::map<CString, CString>& mapSnippet)
1853 {
1854 CString strLine;
1855 try
1856 {
1857 CStdioFile file(sFile, CFile::typeText | CFile::modeRead | CFile::shareDenyWrite);
1858 while (m_bRunThread && file.ReadString(strLine))
1859 {
1860 if (strLine.IsEmpty())
1861 continue;
1862 if (strLine[0] == L'#') // comment char
1863 continue;
1864 const int eqpos = strLine.Find(L'=');
1865 if (eqpos <= 0)
1866 continue;
1867 CString key = strLine.Left(eqpos);
1868 auto rawvalue = strLine.GetBuffer() + eqpos + 1;
1869 CString value;
1870 bool isEscaped = false;
1871 for (int i = 0, len = strLine.GetLength() - eqpos - 1; i < len; ++i)
1872 {
1873 wchar_t c = rawvalue[i];
1874 if (isEscaped)
1875 {
1876 switch (c)
1877 {
1878 case L't': c = L'\t'; break;
1879 case L'n': c = L'\n'; break;
1880 case L'r': c = L'\r'; break;
1881 case L'\\': c = L'\\'; break;
1882 default: value += rawvalue[i - 1]; break; // i is known to be > 0
1883 }
1884 value += c;
1885 isEscaped = false;
1886 }
1887 else if (c == L'\\')
1888 isEscaped = true;
1889 else
1890 value += c;
1891 }
1892 mapSnippet[key] = value;
1893 }
1894 file.Close();
1895 }
1896 catch (CFileException* pE)
1897 {
1898 CTraceToOutputDebugString::Instance()(__FUNCTION__ ": CFileException loading auto list regex file\n");
1899 pE->Delete();
1900 }
1901 }
1902
1903 void CCommitDlg::GetAutocompletionList(std::map<CString, int>& autolist)
1904 {
1905 // the auto completion list is made of strings from each selected files.
1906 // the strings used are extracted from the files with regexes found
1907 // in the file "autolist.txt".
1908 // the format of that file is:
1909 // file extensions separated with commas '=' regular expression to use
1910 // example:
1911 // .h, .hpp = (?<=class[\s])\b\w+\b|(\b\w+(?=[\s ]?\(\);))
1912 // .cpp = (?<=[^\s]::)\b\w+\b
1913
1914 std::map<CString, CString> mapRegex;
1915 CString sRegexFile = CPathUtils::GetAppDirectory();
1916 CRegDWORD regtimeout = CRegDWORD(L"Software\\TortoiseGit\\AutocompleteParseTimeout", 5);
1917 ULONGLONG timeoutvalue = ULONGLONG(DWORD(regtimeout)) * 1000UL;;
1918 sRegexFile += L"autolist.txt";
1919 if (!m_bRunThread)
1920 return;
1921 ParseRegexFile(sRegexFile, mapRegex);
1922 sRegexFile = CPathUtils::GetAppDataDirectory();
1923 sRegexFile += L"autolist.txt";
1924 if (PathFileExists(sRegexFile))
1925 ParseRegexFile(sRegexFile, mapRegex);
1926
1927 m_snippet.clear();
1928 CString sSnippetFile = CPathUtils::GetAppDirectory();
1929 sSnippetFile += L"snippet.txt";
1930 ParseSnippetFile(sSnippetFile, m_snippet);
1931 sSnippetFile = CPathUtils::GetAppDataDirectory();
1932 sSnippetFile += L"snippet.txt";
1933 if (PathFileExists(sSnippetFile))
1934 ParseSnippetFile(sSnippetFile, m_snippet);
1935 for (const auto& snip : m_snippet)
1936 autolist.emplace(snip.first, AUTOCOMPLETE_SNIPPET);
1937
1938 ULONGLONG starttime = GetTickCount64();
1939
1940 // now we have two arrays of strings, where the first array contains all
1941 // file extensions we can use and the second the corresponding regex strings
1942 // to apply to those files.
1943
1944 // the next step is to go over all files shown in the commit dialog
1945 // and scan them for strings we can use
1946 const int nListItems = m_ListCtrl.GetItemCount();
1947
1948 for (int i=0; i<nListItems && m_bRunThread; ++i)
1949 {
1950 // stop parsing after timeout
1951 if ((!m_bRunThread) || (GetTickCount64() - starttime > timeoutvalue))
1952 return;
1953
1954 CString sWinPath;
1955 CString sPartPath;
1956 CString sExt;
1957 int action;
1958 {
1959 auto locker(m_ListCtrl.AcquireReadLock());
1960 auto path = m_ListCtrl.GetListEntry(i);
1961
1962 if (!path)
1963 continue;
1964
1965 sWinPath = path->GetWinPathString();
1966 sPartPath = path->GetGitPathString();
1967 sExt = path->GetFileExtension();
1968 action = path->m_Action;
1969 }
1970 autolist.emplace(sPartPath, AUTOCOMPLETE_FILENAME);
1971
1972 int pos = 0;
1973 int lastPos = 0;
1974 while ((pos = sPartPath.Find('/', pos)) >= 0)
1975 {
1976 ++pos;
1977 lastPos = pos;
1978 autolist.emplace(sPartPath.Mid(pos), AUTOCOMPLETE_FILENAME);
1979 }
1980
1981 // Last inserted entry is a file name.
1982 // Some users prefer to also list file name without extension.
1983 if (CRegDWORD(L"Software\\TortoiseGit\\AutocompleteRemovesExtensions", FALSE))
1984 {
1985 const int dotPos = sPartPath.ReverseFind('.');
1986 if ((dotPos >= 0) && (dotPos > lastPos))
1987 autolist.emplace(sPartPath.Mid(lastPos, dotPos - lastPos), AUTOCOMPLETE_FILENAME);
1988 }
1989
1990 if (action == CTGitPath::LOGACTIONS_UNVER && !CRegDWORD(L"Software\\TortoiseGit\\AutocompleteParseUnversioned", FALSE))
1991 continue;
1992 if (action == CTGitPath::LOGACTIONS_IGNORE)
1993 continue;
1994
1995 sExt.MakeLower();
1996 // find the regex string which corresponds to the file extension
1997 CString rdata = mapRegex[sExt];
1998 if (rdata.IsEmpty())
1999 continue;
2000
2001 ScanFile(autolist, sWinPath, rdata, sExt);
2002 }
2003 CTraceToOutputDebugString::Instance()(_T(__FUNCTION__) L": Auto completion list loaded in %I64u msec\n", GetTickCount64() - starttime);
2004 }
2005
2006 void CCommitDlg::ScanFile(std::map<CString, int>& autolist, const CString& sFilePath, const CString& sRegex, const CString& sExt)
2007 {
2008 static std::map<CString, std::wregex> regexmap;
2009
2010 CAutoFile hFile = CreateFile(sFilePath, GENERIC_READ, FILE_SHARE_READ, nullptr, OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, nullptr);
2011 if (!hFile)
2012 return;
2013
2014 LARGE_INTEGER fileSize;
2015 if (GetFileSizeEx(hFile, &fileSize); fileSize.QuadPart == 0 || fileSize.QuadPart >= INT_MAX || fileSize.QuadPart > CRegDWORD(L"Software\\TortoiseGit\\AutocompleteParseMaxSize", 300000L))
2016 {
2017 // no empty files or files bigger than a configurable maximum (default: 300k)
2018 return;
2019 }
2020 // allocate memory to hold file contents
2021 std::unique_ptr<BYTE[]> fileBuffer;
2022 try
2023 {
2024 fileBuffer = std::unique_ptr<BYTE[]>(new BYTE[fileSize.LowPart]); // prevent default initialization
2025 }
2026 catch (CMemoryException*)
2027 {
2028 return;
2029 }
2030 DWORD readbytes;
2031 if (!ReadFile(hFile, fileBuffer.get(), fileSize.LowPart, &readbytes, nullptr))
2032 return;
2033 CFileTextLines filetextlines;
2034 CFileTextLines::UnicodeType type = filetextlines.CheckUnicodeType(fileBuffer.get(), readbytes);
2035 std::unique_ptr<CDecodeFilter> pFilter;
2036 try
2037 {
2038 switch (type)
2039 {
2040 case CFileTextLines::UnicodeType::BINARY:
2041 return;
2042 case CFileTextLines::UnicodeType::UTF8:
2043 case CFileTextLines::UnicodeType::UTF8BOM:
2044 pFilter = std::make_unique<CUtf8Filter>(nullptr);
2045 break;
2046 default:
2047 case CFileTextLines::UnicodeType::ASCII:
2048 pFilter = std::make_unique<CAsciiFilter>(nullptr);
2049 break;
2050 case CFileTextLines::UnicodeType::UTF16_BE:
2051 case CFileTextLines::UnicodeType::UTF16_BEBOM:
2052 pFilter = std::make_unique<CUtf16beFilter>(nullptr);
2053 break;
2054 case CFileTextLines::UnicodeType::UTF16_LE:
2055 case CFileTextLines::UnicodeType::UTF16_LEBOM:
2056 pFilter = std::make_unique<CUtf16leFilter>(nullptr);
2057 break;
2058 case CFileTextLines::UnicodeType::UTF32_BE:
2059 pFilter = std::make_unique<CUtf32beFilter>(nullptr);
2060 break;
2061 case CFileTextLines::UnicodeType::UTF32_LE:
2062 pFilter = std::make_unique<CUtf32leFilter>(nullptr);
2063 break;
2064 }
2065 if (!pFilter->Decode(std::move(fileBuffer), readbytes))
2066 return;
2067 }
2068 catch (CMemoryException*)
2069 {
2070 return;
2071 }
2072
2073 std::wstring_view sFileContent = pFilter->GetStringView();
2074 if (sFileContent.empty() || !m_bRunThread)
2075 return;
2076
2077 try
2078 {
2079 std::wregex regCheck;
2080 std::map<CString, std::wregex>::const_iterator regIt;
2081 if ((regIt = regexmap.find(sExt)) != regexmap.end())
2082 regCheck = regIt->second;
2083 else
2084 {
2085 regCheck = std::wregex(sRegex, std::regex_constants::icase | std::regex_constants::ECMAScript);
2086 regexmap[sExt] = regCheck;
2087 }
2088 const std::wcregex_iterator end;
2089 for (std::wcregex_iterator it(sFileContent.data(), sFileContent.data() + sFileContent.size(), regCheck); it != end; ++it)
2090 {
2091 const std::wcmatch match = *it;
2092 for (size_t i = 1; i < match.size(); ++i)
2093 {
2094 if (match[i].second-match[i].first)
2095 autolist.emplace(std::wstring(match[i]).c_str(), AUTOCOMPLETE_PROGRAMCODE);
2096 }
2097 }
2098 }
2099 catch (std::exception&) {}
2100 }
2101
2102 // CSciEditContextMenuInterface
2103 void CCommitDlg::InsertMenuItems(CMenu& mPopup, int& nCmd)
2104 {
2105 CString sMenuItemText;
2106 sMenuItemText.LoadString(IDS_COMMITDLG_POPUP_PICKCOMMITHASH);
2107 m_nPopupPickCommitHash = nCmd++;
2108 mPopup.AppendMenu(MF_STRING | MF_ENABLED, m_nPopupPickCommitHash, sMenuItemText);
2109
2110 sMenuItemText.LoadString(IDS_COMMITDLG_POPUP_PICKCOMMITMESSAGE);
2111 m_nPopupPickCommitMessage = nCmd++;
2112 mPopup.AppendMenu(MF_STRING | MF_ENABLED, m_nPopupPickCommitMessage, sMenuItemText);
2113
2114 sMenuItemText.LoadString(IDS_COMMITDLG_POPUP_PASTEFILELIST);
2115 m_nPopupPasteListCmd = nCmd++;
2116 mPopup.AppendMenu(MF_STRING | MF_ENABLED, m_nPopupPasteListCmd, sMenuItemText);
2117
2118 ReloadHistoryEntries();
2119 if (!m_History.IsEmpty())
2120 {
2121 sMenuItemText.LoadString(IDS_COMMITDLG_POPUP_PASTELASTMESSAGE);
2122 m_nPopupPasteLastMessage = nCmd++;
2123 mPopup.AppendMenu(MF_STRING | MF_ENABLED, m_nPopupPasteLastMessage, sMenuItemText);
2124
2125 sMenuItemText.LoadString(IDS_COMMITDLG_POPUP_LOGHISTORY);
2126 m_nPopupRecentMessage = nCmd++;
2127 mPopup.AppendMenu(MF_STRING | MF_ENABLED, m_nPopupRecentMessage, sMenuItemText);
2128 }
2129 }
2130
2131 bool CCommitDlg::HandleMenuItemClick(int cmd, CSciEdit * pSciEdit)
2132 {
2133 if (cmd == m_nPopupPickCommitHash)
2134 {
2135 // use the git log to allow selection of a version
2136 CLogDlg dlg;
2137 if (dlg.IsThreadRunning())
2138 {
2139 CMessageBox::Show(GetSafeHwnd(), IDS_PROC_LOG_ONLYONCE, IDS_APPNAME, MB_ICONEXCLAMATION);
2140 return true;
2141 }
2142 // tell the dialog to use mode for selecting revisions
2143 dlg.SetSelect(true);
2144 // only one revision must be selected however
2145 dlg.SingleSelection(true);
2146 dlg.ShowWorkingTreeChanges(false);
2147 if (dlg.DoModal() == IDOK && !dlg.GetSelectedHash().empty())
2148 pSciEdit->InsertText(dlg.GetSelectedHash().at(0).ToString());
2149 BringWindowToTop(); /* cf. issue #3493 */
2150 return true;
2151 }
2152
2153 if (cmd == m_nPopupPickCommitMessage)
2154 {
2155 // use the git log to allow selection of a version
2156 CLogDlg dlg;
2157 if (dlg.IsThreadRunning())
2158 {
2159 CMessageBox::Show(GetSafeHwnd(), IDS_PROC_LOG_ONLYONCE, IDS_APPNAME, MB_ICONEXCLAMATION);
2160 return true;
2161 }
2162 // tell the dialog to use mode for selecting revisions
2163 dlg.SetSelect(true);
2164 // only one revision must be selected however
2165 dlg.SingleSelection(true);
2166 dlg.ShowWorkingTreeChanges(false);
2167 if (dlg.DoModal() == IDOK && !dlg.GetSelectedHash().empty())
2168 {
2169 GitRev rev;
2170 if (rev.GetCommit(dlg.GetSelectedHash().at(0).ToString()))
2171 {
2172 MessageBox(rev.GetLastErr(), L"TortoiseGit", MB_ICONERROR);
2173 return false;
2174 }
2175 CString message = rev.GetSubject() + L"\r\n" + rev.GetBody();
2176 pSciEdit->InsertText(message);
2177 }
2178 BringWindowToTop(); /* cf. issue #3493 */
2179 return true;
2180 }
2181
2182 if (cmd == m_nPopupPasteListCmd)
2183 {
2184 CString logmsg;
2185 auto locker(m_ListCtrl.AcquireReadLock());
2186 const int nListItems = m_ListCtrl.GetItemCount();
2187 for (int i=0; i<nListItems; ++i)
2188 {
2189 auto entry = m_ListCtrl.GetListEntry(i);
2190 if (entry&&entry->m_Checked)
2191 {
2192 CString status = entry->GetActionName();
2193 if(entry->m_Action & CTGitPath::LOGACTIONS_UNVER)
2194 status = CTGitPath::GetActionName(CTGitPath::LOGACTIONS_ADDED);
2195
2196 //git_wc_status_kind status = entry->status;
2197 WORD langID = static_cast<WORD>(CRegStdDWORD(L"Software\\TortoiseGit\\LanguageID", GetUserDefaultLangID()));
2198 if (m_ProjectProperties.bFileListInEnglish)
2199 langID = 1033;
2200
2201 logmsg.AppendFormat(L"%-10s %s\r\n", static_cast<LPCWSTR>(status), static_cast<LPCWSTR>(m_ListCtrl.GetItemText(i, 0)));
2202 }
2203 }
2204 pSciEdit->InsertText(logmsg);
2205 return true;
2206 }
2207
2208 if(cmd == m_nPopupPasteLastMessage)
2209 {
2210 if (m_History.IsEmpty())
2211 return false;
2212
2213 CString logmsg;
2214 logmsg +=m_History.GetEntry(0);
2215 pSciEdit->InsertText(logmsg);
2216 return true;
2217 }
2218
2219 if(cmd == m_nPopupRecentMessage )
2220 {
2221 OnBnClickedHistory();
2222 return true;
2223 }
2224 return false;
2225 }
2226
2227 void CCommitDlg::HandleSnippet(int type, const CString &text, CSciEdit *pSciEdit)
2228 {
2229 if (type == AUTOCOMPLETE_SNIPPET)
2230 {
2231 CString target = m_snippet[text];
2232 pSciEdit->GetWordUnderCursor(true);
2233 pSciEdit->InsertText(target, false);
2234 }
2235 }
2236
2237 void CCommitDlg::OnTimer(UINT_PTR nIDEvent)
2238 {
2239 switch (nIDEvent)
2240 {
2241 case ENDDIALOGTIMER:
2242 KillTimer(ENDDIALOGTIMER);
2243 EndDialog(0);
2244 break;
2245 case REFRESHTIMER:
2246 if (m_bThreadRunning)
2247 {
2248 SetTimer(REFRESHTIMER, 200, nullptr);
2249 CTraceToOutputDebugString::Instance()(__FUNCTION__ ": Wait some more before refreshing\n");
2250 }
2251 else
2252 {
2253 KillTimer(REFRESHTIMER);
2254 CTraceToOutputDebugString::Instance()(__FUNCTION__ ": Refreshing after items dropped\n");
2255 Refresh();
2256 }
2257 break;
2258 case FILLPATCHVTIMER:
2259 FillPatchView();
2260 break;
2261 }
2262 __super::OnTimer(nIDEvent);
2263 }
2264
2265 void CCommitDlg::OnBnClickedHistory()
2266 {
2267 m_tooltips.Pop(); // hide the tooltips
2268 if (m_pathList.IsEmpty())
2269 return;
2270
2271 CHistoryDlg historyDlg;
2272 ReloadHistoryEntries();
2273 historyDlg.SetHistory(m_History);
2274 if (historyDlg.DoModal() != IDOK)
2275 return;
2276
2277 CString sMsg = historyDlg.GetSelectedText();
2278 if (sMsg != m_cLogMessage.GetText().Left(sMsg.GetLength()))
2279 {
2280 CString sBugID = m_ProjectProperties.FindBugID(sMsg);
2281 if ((!sBugID.IsEmpty()) && ((GetDlgItem(IDC_BUGID)->IsWindowVisible())))
2282 SetDlgItemText(IDC_BUGID, sBugID);
2283 if (m_sLogTemplate.Compare(m_cLogMessage.GetText()) != 0)
2284 m_cLogMessage.InsertText(sMsg, !m_cLogMessage.GetText().IsEmpty());
2285 else
2286 m_cLogMessage.SetText(sMsg);
2287 }
2288
2289 SendMessage(WM_UPDATEOKBUTTON);
2290 GetDlgItem(IDC_LOGMESSAGE)->SetFocus();
2291 }
2292
2293 void CCommitDlg::OnBnClickedBugtraqbutton()
2294 {
2295 m_tooltips.Pop(); // hide the tooltips
2296 CString sMsg = m_cLogMessage.GetText();
2297
2298 if (!m_BugTraqProvider)
2299 return;
2300
2301 ATL::CComBSTR parameters(m_bugtraq_association.GetParameters());
2302 ATL::CComBSTR commonRoot(m_pathList.GetCommonRoot().GetDirectory().GetWinPath());
2303 CBstrSafeVector pathList(m_pathList.GetCount());
2304
2305 for (LONG index = 0; index < m_pathList.GetCount(); ++index)
2306 pathList.PutElement(index, m_pathList[index].GetGitPathString());
2307
2308 ATL::CComBSTR originalMessage(sMsg);
2309 ATL::CComBSTR temp;
2310
2311 // first try the IBugTraqProvider2 interface
2312 CComPtr<IBugTraqProvider2> pProvider2;
2313 HRESULT hr = m_BugTraqProvider.QueryInterface(&pProvider2);
2314 bool bugIdOutSet = false;
2315 if (SUCCEEDED(hr))
2316 {
2317 ATL::CComBSTR repositoryRoot(g_Git.m_CurrentDir);
2318 ATL::CComBSTR bugIDOut;
2319 GetDlgItemText(IDC_BUGID, m_sBugID);
2320 ATL::CComBSTR bugID(m_sBugID);
2321 CBstrSafeVector revPropNames;
2322 CBstrSafeVector revPropValues;
2323 if (FAILED(hr = pProvider2->GetCommitMessage2(GetSafeHwnd(), parameters, repositoryRoot, commonRoot, pathList, originalMessage, bugID, &bugIDOut, &revPropNames, &revPropValues, &temp)))
2324 {
2325 CString sErr;
2326 sErr.FormatMessage(IDS_ERR_FAILEDISSUETRACKERCOM, static_cast<LPCWSTR>(m_bugtraq_association.GetProviderName()), _com_error(hr).ErrorMessage());
2327 CMessageBox::Show(GetSafeHwnd(), sErr, L"TortoiseGit", MB_ICONERROR);
2328 }
2329 else
2330 {
2331 if (bugIDOut)
2332 {
2333 bugIdOutSet = true;
2334 m_sBugID = bugIDOut;
2335 SetDlgItemText(IDC_BUGID, m_sBugID);
2336 }
2337 m_cLogMessage.SetText(static_cast<LPCWSTR>(temp));
2338 }
2339 }
2340 else
2341 {
2342 // if IBugTraqProvider2 failed, try IBugTraqProvider
2343 CComPtr<IBugTraqProvider> pProvider;
2344 hr = m_BugTraqProvider.QueryInterface(&pProvider);
2345 if (FAILED(hr))
2346 {
2347 CString sErr;
2348 sErr.FormatMessage(IDS_ERR_FAILEDISSUETRACKERCOM, static_cast<LPCWSTR>(m_bugtraq_association.GetProviderName()), _com_error(hr).ErrorMessage());
2349 CMessageBox::Show(GetSafeHwnd(), sErr, L"TortoiseGit", MB_ICONERROR);
2350 return;
2351 }
2352
2353 if (FAILED(hr = pProvider->GetCommitMessage(GetSafeHwnd(), parameters, commonRoot, pathList, originalMessage, &temp)))
2354 {
2355 CString sErr;
2356 sErr.FormatMessage(IDS_ERR_FAILEDISSUETRACKERCOM, static_cast<LPCWSTR>(m_bugtraq_association.GetProviderName()), _com_error(hr).ErrorMessage());
2357 CMessageBox::Show(GetSafeHwnd(), sErr, L"TortoiseGit", MB_ICONERROR);
2358 }
2359 else
2360 m_cLogMessage.SetText(static_cast<LPCWSTR>(temp));
2361 }
2362 m_sLogMessage = m_cLogMessage.GetText();
2363 if (!m_ProjectProperties.sMessage.IsEmpty())
2364 {
2365 CString sBugID = m_ProjectProperties.FindBugID(m_sLogMessage);
2366 if (!sBugID.IsEmpty() && !bugIdOutSet)
2367 SetDlgItemText(IDC_BUGID, sBugID);
2368 }
2369
2370 m_cLogMessage.SetFocus();
2371 }
2372
2373 void CCommitDlg::FillPatchView(bool onlySetTimer)
2374 {
2375 if(::IsWindow(this->m_patchViewdlg.m_hWnd))
2376 {
2377 KillTimer(FILLPATCHVTIMER);
2378 if (onlySetTimer)
2379 {
2380 SetTimer(FILLPATCHVTIMER, 100, nullptr);
2381 return;
2382 }
2383
2384 auto locker(m_ListCtrl.AcquireReadWeakLock(50));
2385 if (!locker.IsAcquired())
2386 {
2387 SetTimer(FILLPATCHVTIMER, 100, nullptr);
2388 return;
2389 }
2390 POSITION pos=m_ListCtrl.GetFirstSelectedItemPosition();
2391 CString cmd,out;
2392
2393 CString head = L"HEAD";
2394 if (m_bCommitAmend == TRUE && m_bAmendDiffToLastCommit == FALSE)
2395 head = L"HEAD~1";
2396 while(pos)
2397 {
2398 const int nSelect = m_ListCtrl.GetNextSelectedItem(pos);
2399 auto p = m_ListCtrl.GetListEntry(nSelect);
2400 if(p && !(p->m_Action&CTGitPath::LOGACTIONS_UNVER) )
2401 {
2402 if (m_bStagingSupport)
2403 {
2404 // This will only work if called after ShowPartialStagingTextAndUpdateDisplayStatus (or Unstaging)
2405
2406 if (!(p->m_Action & CTGitPath::LOGACTIONS_ADDED) && !(p->m_Action & CTGitPath::LOGACTIONS_DELETED) && !(p->m_Action & CTGitPath::LOGACTIONS_MISSING) && !(p->m_Action & CTGitPath::LOGACTIONS_UNMERGED) && !(p->IsDirectory()))
2407 {
2408 if (!(m_stagingDisplayState & SHOW_STAGING)) // link does not currently display show staging, then it's "hide staging", meaning the staging window is open
2409 m_patchViewdlg.EnableStaging(EnableStagingTypes::Staging);
2410 else if (!(m_stagingDisplayState & SHOW_UNSTAGING)) // link does not currently display show unstaging, then it's "hide unstaging", meaning the unstaging window is open
2411 m_patchViewdlg.EnableStaging(EnableStagingTypes::Unstaging);
2412 }
2413 else
2414 m_patchViewdlg.EnableStaging(EnableStagingTypes::None);
2415
2416 bool useCachedParameter = false;
2417 if (!(m_stagingDisplayState & SHOW_UNSTAGING)) // link does not currently display show unstaging, then it's "hide unstaging", meaning the unstaging window is open
2418 useCachedParameter = true;
2419 else
2420 head.Empty();
2421
2422 if (!p->GetGitOldPathString().IsEmpty())
2423 cmd.Format(L"git.exe diff %s%s -- \"%s\" \"%s\"", static_cast<LPCWSTR>(head), useCachedParameter ? L" --cached" : L"", static_cast<LPCWSTR>(p->GetGitOldPathString()), static_cast<LPCWSTR>(p->GetGitPathString()));
2424 else
2425 cmd.Format(L"git.exe diff %s%s -- \"%s\"", static_cast<LPCWSTR>(head), useCachedParameter ? L" --cached" : L"", static_cast<LPCWSTR>(p->GetGitPathString()));
2426 }
2427 else
2428 {
2429 if (!p->GetGitOldPathString().IsEmpty())
2430 cmd.Format(L"git.exe diff %s -- \"%s\" \"%s\"", static_cast<LPCWSTR>(head), static_cast<LPCWSTR>(p->GetGitOldPathString()), static_cast<LPCWSTR>(p->GetGitPathString()));
2431 else
2432 cmd.Format(L"git.exe diff %s -- \"%s\"", static_cast<LPCWSTR>(head), static_cast<LPCWSTR>(p->GetGitPathString()));
2433 }
2434 g_Git.Run(cmd, &out, CP_UTF8);
2435 }
2436 else
2437 m_patchViewdlg.EnableStaging(EnableStagingTypes::None);
2438 if (m_bStagingSupport)
2439 break; // only one file at a time (the hunk staging code supports many files at once, so it's possible to relax this restriction for that case)
2440 }
2441
2442 m_patchViewdlg.SetText(out);
2443 }
2444 }
2445 LRESULT CCommitDlg::OnGitStatusListCtrlItemChanged(WPARAM /*wparam*/, LPARAM /*lparam*/)
2446 {
2447 // This handler is blocked during a partial staging, because OnPartialStagingRefreshPatchView itself calls FillPatchView
2448 if (!m_nBlockItemChangeHandler)
2449 this->FillPatchView(true);
2450 return 0;
2451 }
2452
2453
2454 LRESULT CCommitDlg::OnGitStatusListCtrlCheckChanged(WPARAM, LPARAM)
2455 {
2456 SendMessage(WM_UPDATEOKBUTTON);
2457 return 0;
2458 }
2459
2460 LRESULT CCommitDlg::OnCheck(WPARAM wnd, LPARAM)
2461 {
2462 HWND hwnd = reinterpret_cast<HWND>(wnd);
2463 const bool check = !(GetAsyncKeyState(VK_SHIFT) & 0x8000);
2464 if (hwnd == GetDlgItem(IDC_CHECKALL)->GetSafeHwnd())
2465 m_ListCtrl.Check(GITSLC_SHOWEVERYTHING, check);
2466 else if (hwnd == GetDlgItem(IDC_CHECKNONE)->GetSafeHwnd())
2467 m_ListCtrl.Check(GITSLC_SHOWEVERYTHING, !check);
2468 else if (hwnd == GetDlgItem(IDC_CHECKUNVERSIONED)->GetSafeHwnd())
2469 m_ListCtrl.Check(GITSLC_SHOWUNVERSIONED, check);
2470 else if (hwnd == GetDlgItem(IDC_CHECKVERSIONED)->GetSafeHwnd())
2471 m_ListCtrl.Check(GITSLC_SHOWVERSIONED, check);
2472 else if (hwnd == GetDlgItem(IDC_CHECKADDED)->GetSafeHwnd())
2473 m_ListCtrl.Check(GITSLC_SHOWADDED, check);
2474 else if (hwnd == GetDlgItem(IDC_CHECKDELETED)->GetSafeHwnd())
2475 m_ListCtrl.Check(GITSLC_SHOWREMOVED, check);
2476 else if (hwnd == GetDlgItem(IDC_CHECKMODIFIED)->GetSafeHwnd())
2477 m_ListCtrl.Check(GITSLC_SHOWMODIFIED, check);
2478 else if (hwnd == GetDlgItem(IDC_CHECKFILES)->GetSafeHwnd())
2479 m_ListCtrl.Check(GITSLC_SHOWFILES, check);
2480 else if (hwnd == GetDlgItem(IDC_CHECKSUBMODULES)->GetSafeHwnd())
2481 m_ListCtrl.Check(GITSLC_SHOWSUBMODULES, check);
2482
2483 return 0;
2484 }
2485
2486 LRESULT CCommitDlg::OnUpdateOKButton(WPARAM, LPARAM)
2487 {
2488 if (m_bBlock)
2489 return 0;
2490
2491 CString text = m_cLogMessage.GetText().Trim();
2492 const bool bValidLogSize = !text.IsEmpty() && text.GetLength() >= m_ProjectProperties.nMinLogSize;
2493 const bool bAmendOrSelectFilesOrMerge = m_ListCtrl.GetSelected() > 0 || (m_bCommitAmend && m_bAmendDiffToLastCommit) || CTGitPath(g_Git.m_CurrentDir).IsMergeActive();
2494
2495 DialogEnableWindow(IDOK, bValidLogSize && (m_bCommitMessageOnly || bAmendOrSelectFilesOrMerge));
2496
2497 return 0;
2498 }
2499
2500 LRESULT CCommitDlg::OnUpdateDataFalse(WPARAM, LPARAM)
2501 {
2502 UpdateData(FALSE);
2503 return 0;
2504 }
2505
2506 LRESULT CCommitDlg::OnPartialStagingRefreshPatchView(WPARAM wParam, LPARAM)
2507 {
2508 m_patchViewdlg.ClearView();
2509
2510 {
2511 // Block the item change handler to make sure FillPatchView is called only once (below)
2512 ScopedInDecrement blocker(m_nBlockItemChangeHandler);
2513 CTGitPath::StagingStatus newStatus = static_cast<CTGitPath::StagingStatus>(wParam);
2514 m_ListCtrl.UpdateSelectedFileStagingStatus(newStatus);
2515 }
2516
2517 FillPatchView();
2518 SendMessage(WM_UPDATEOKBUTTON);
2519 return 0;
2520 }
2521
2522 LRESULT CCommitDlg::DefWindowProc(UINT message, WPARAM wParam, LPARAM lParam)
2523 {
2524 switch (message) {
2525 case WM_NOTIFY:
2526 if (wParam == IDC_SPLITTER)
2527 {
2528 auto pHdr = reinterpret_cast<SPC_NMHDR*>(lParam);
2529 DoSize(pHdr->delta);
2530 }
2531 break;
2532 case WM_COMMAND:
2533 if (m_hAccelOkButton && LOWORD(wParam) >= WM_USER && LOWORD(wParam) <= WM_USER + m_accellerators.size())
2534 {
2535 for (const auto& entry : m_accellerators)
2536 {
2537 if (entry.second.wmid != LOWORD(wParam))
2538 continue;
2539 if (entry.second.id == -1)
2540 m_ctrlOkButton.PostMessage(WM_KEYDOWN, VK_F4, NULL);
2541 else
2542 {
2543 m_ctrlOkButton.SetCurrentEntry(entry.second.id);
2544 OnOK();
2545 }
2546 return 0;
2547 }
2548 }
2549 break;
2550 }
2551
2552 return __super::DefWindowProc(message, wParam, lParam);
2553 }
2554
2555 void CCommitDlg::SetSplitterRange()
2556 {
2557 if ((m_ListCtrl)&&(m_cLogMessage))
2558 {
2559 CRect rcTop;
2560 m_cLogMessage.GetWindowRect(rcTop);
2561 ScreenToClient(rcTop);
2562 CRect rcMiddle;
2563 m_ListCtrl.GetWindowRect(rcMiddle);
2564 ScreenToClient(rcMiddle);
2565 if (rcMiddle.Height() && rcMiddle.Width())
2566 m_wndSplitter.SetRange(rcTop.top + CDPIAware::Instance().ScaleY(GetSafeHwnd(), 120), rcMiddle.bottom - CDPIAware::Instance().ScaleY(GetSafeHwnd(), 80));
2567 }
2568 }
2569
2570 void CCommitDlg::DoSize(int delta)
2571 {
2572 RemoveAnchor(IDC_MESSAGEGROUP);
2573 RemoveAnchor(IDC_LOGMESSAGE);
2574 RemoveAnchor(IDC_SPLITTER);
2575 RemoveAnchor(IDC_SIGNOFF);
2576 RemoveAnchor(IDC_COMMIT_AMEND);
2577 RemoveAnchor(IDC_COMMIT_AMENDDIFF);
2578 RemoveAnchor(IDC_COMMIT_SETDATETIME);
2579 RemoveAnchor(IDC_COMMIT_DATEPICKER);
2580 RemoveAnchor(IDC_COMMIT_TIMEPICKER);
2581 RemoveAnchor(IDC_COMMIT_AS_COMMIT_DATE);
2582 RemoveAnchor(IDC_COMMIT_SETAUTHOR);
2583 RemoveAnchor(IDC_COMMIT_AUTHORDATA);
2584 RemoveAnchor(IDC_LISTGROUP);
2585 RemoveAnchor(IDC_FILELIST);
2586 RemoveAnchor(IDC_TEXT_INFO);
2587 RemoveAnchor(IDC_SELECTLABEL);
2588 RemoveAnchor(IDC_CHECKALL);
2589 RemoveAnchor(IDC_CHECKNONE);
2590 RemoveAnchor(IDC_CHECKUNVERSIONED);
2591 RemoveAnchor(IDC_CHECKVERSIONED);
2592 RemoveAnchor(IDC_CHECKADDED);
2593 RemoveAnchor(IDC_CHECKDELETED);
2594 RemoveAnchor(IDC_CHECKMODIFIED);
2595 RemoveAnchor(IDC_CHECKFILES);
2596 RemoveAnchor(IDC_CHECKSUBMODULES);
2597
2598 auto hdwp = BeginDeferWindowPos(24);
2599 CSplitterControl::ChangeRect(hdwp, &m_cLogMessage, 0, 0, 0, delta);
2600 CSplitterControl::ChangeRect(hdwp, GetDlgItem(IDC_MESSAGEGROUP), 0, 0, 0, delta);
2601 CSplitterControl::ChangeRect(hdwp, &m_ListCtrl, 0, delta, 0, 0);
2602 CSplitterControl::ChangeRect(hdwp, GetDlgItem(IDC_LISTGROUP), 0, delta, 0, 0);
2603 CSplitterControl::ChangeRect(hdwp, GetDlgItem(IDC_SIGNOFF), 0, delta, 0, delta);
2604 CSplitterControl::ChangeRect(hdwp, GetDlgItem(IDC_COMMIT_AMEND), 0, delta, 0, delta);
2605 CSplitterControl::ChangeRect(hdwp, GetDlgItem(IDC_COMMIT_AMENDDIFF), 0, delta, 0, delta);
2606 CSplitterControl::ChangeRect(hdwp, GetDlgItem(IDC_COMMIT_SETDATETIME), 0, delta, 0, delta);
2607 CSplitterControl::ChangeRect(hdwp, GetDlgItem(IDC_COMMIT_DATEPICKER), 0, delta, 0, delta);
2608 CSplitterControl::ChangeRect(hdwp, GetDlgItem(IDC_COMMIT_TIMEPICKER), 0, delta, 0, delta);
2609 CSplitterControl::ChangeRect(hdwp, GetDlgItem(IDC_COMMIT_AS_COMMIT_DATE), 0, delta, 0, delta);
2610 CSplitterControl::ChangeRect(hdwp, GetDlgItem(IDC_COMMIT_SETAUTHOR), 0, delta, 0, delta);
2611 CSplitterControl::ChangeRect(hdwp, GetDlgItem(IDC_COMMIT_AUTHORDATA), 0, delta, 0, delta);
2612 CSplitterControl::ChangeRect(hdwp, GetDlgItem(IDC_TEXT_INFO), 0, delta, 0, delta);
2613 CSplitterControl::ChangeRect(hdwp, GetDlgItem(IDC_SELECTLABEL), 0, delta, 0, delta);
2614 CSplitterControl::ChangeRect(hdwp, GetDlgItem(IDC_CHECKALL), 0, delta, 0, delta);
2615 CSplitterControl::ChangeRect(hdwp, GetDlgItem(IDC_CHECKNONE), 0, delta, 0, delta);
2616 CSplitterControl::ChangeRect(hdwp, GetDlgItem(IDC_CHECKUNVERSIONED), 0, delta, 0, delta);
2617 CSplitterControl::ChangeRect(hdwp, GetDlgItem(IDC_CHECKVERSIONED), 0, delta, 0, delta);
2618 CSplitterControl::ChangeRect(hdwp, GetDlgItem(IDC_CHECKADDED), 0, delta, 0, delta);
2619 CSplitterControl::ChangeRect(hdwp, GetDlgItem(IDC_CHECKDELETED), 0, delta, 0, delta);
2620 CSplitterControl::ChangeRect(hdwp, GetDlgItem(IDC_CHECKMODIFIED), 0, delta, 0, delta);
2621 CSplitterControl::ChangeRect(hdwp, GetDlgItem(IDC_CHECKFILES), 0, delta, 0, delta);
2622 CSplitterControl::ChangeRect(hdwp, GetDlgItem(IDC_CHECKSUBMODULES), 0, delta, 0, delta);
2623 EndDeferWindowPos(hdwp);
2624
2625 AddAnchor(IDC_MESSAGEGROUP, TOP_LEFT, TOP_RIGHT);
2626 AddAnchor(IDC_LOGMESSAGE, TOP_LEFT, TOP_RIGHT);
2627 AddAnchor(IDC_SPLITTER, TOP_LEFT, TOP_RIGHT);
2628 AddAnchor(IDC_LISTGROUP, TOP_LEFT, BOTTOM_RIGHT);
2629 AddAnchor(IDC_FILELIST, TOP_LEFT, BOTTOM_RIGHT);
2630 AddAnchor(IDC_SIGNOFF,TOP_RIGHT);
2631 AddAnchor(IDC_COMMIT_AMEND,TOP_LEFT);
2632 AddAnchor(IDC_COMMIT_AMENDDIFF,TOP_LEFT);
2633 AddAnchor(IDC_COMMIT_SETDATETIME,TOP_LEFT);
2634 AddAnchor(IDC_COMMIT_DATEPICKER,TOP_LEFT);
2635 AddAnchor(IDC_COMMIT_TIMEPICKER,TOP_LEFT);
2636 AddAnchor(IDC_COMMIT_AS_COMMIT_DATE, TOP_LEFT);
2637 AddAnchor(IDC_COMMIT_SETAUTHOR, TOP_LEFT);
2638 AddAnchor(IDC_COMMIT_AUTHORDATA, TOP_LEFT, TOP_RIGHT);
2639 AddAnchor(IDC_TEXT_INFO,TOP_RIGHT);
2640 AddAnchor(IDC_SELECTLABEL, TOP_LEFT);
2641 AddAnchor(IDC_CHECKALL, TOP_LEFT);
2642 AddAnchor(IDC_CHECKNONE, TOP_LEFT);
2643 AddAnchor(IDC_CHECKUNVERSIONED, TOP_LEFT);
2644 AddAnchor(IDC_CHECKVERSIONED, TOP_LEFT);
2645 AddAnchor(IDC_CHECKADDED, TOP_LEFT);
2646 AddAnchor(IDC_CHECKDELETED, TOP_LEFT);
2647 AddAnchor(IDC_CHECKMODIFIED, TOP_LEFT);
2648 AddAnchor(IDC_CHECKFILES, TOP_LEFT);
2649 AddAnchor(IDC_CHECKSUBMODULES, TOP_LEFT);
2650 ArrangeLayout();
2651 // adjust the minimum size of the dialog to prevent the resizing from
2652 // moving the list control too far down.
2653 CRect rcLogMsg;
2654 m_cLogMessage.GetClientRect(rcLogMsg);
2655 SetMinTrackSize(CSize(m_DlgOrigRect.Width(), m_DlgOrigRect.Height()-m_LogMsgOrigRect.Height()+rcLogMsg.Height()));
2656
2657 SetSplitterRange();
2658 m_cLogMessage.Invalidate();
2659 GetDlgItem(IDC_LOGMESSAGE)->Invalidate();
2660 }
2661
2662 void CCommitDlg::OnSize(UINT nType, int cx, int cy)
2663 {
2664 // first, let the resizing take place
2665 __super::OnSize(nType, cx, cy);
2666
2667 //set range
2668 SetSplitterRange();
2669 }
2670
2671 CString CCommitDlg::GetSignedOffByLine()
2672 {
2673 CString str;
2674
2675 CString username = g_Git.GetUserName();
2676 CString email = g_Git.GetUserEmail();
2677 username.Remove(L'\n');
2678 email.Remove(L'\n');
2679
2680 str.Format(L"Signed-off-by: %s <%s>", static_cast<LPCWSTR>(username), static_cast<LPCWSTR>(email));
2681
2682 return str;
2683 }
2684
2685 void CCommitDlg::OnBnClickedSignOff()
2686 {
2687 CString str = GetSignedOffByLine();
2688
2689 if (m_cLogMessage.GetText().Find(str) == -1) {
2690 m_cLogMessage.SetText(m_cLogMessage.GetText().TrimRight());
2691 const int lastNewline = m_cLogMessage.GetText().ReverseFind(L'\n');
2692 int foundByLine = -1;
2693 if (lastNewline > 0)
2694 foundByLine = m_cLogMessage.GetText().Find(L"-by: ", lastNewline);
2695
2696 if (foundByLine == -1 || foundByLine < lastNewline)
2697 str = L"\r\n" + str;
2698
2699 m_cLogMessage.SetText(m_cLogMessage.GetText() + L"\r\n" + str + L"\r\n");
2700 }
2701 }
2702
2703 void CCommitDlg::OnBnClickedCommitAmend()
2704 {
2705 this->UpdateData();
2706 if(this->m_bCommitAmend && this->m_AmendStr.IsEmpty())
2707 {
2708 GitRev rev;
2709 if (rev.GetCommit(L"HEAD"))
2710 MessageBox(rev.GetLastErr(), L"TortoiseGit", MB_ICONERROR);
2711 m_AmendStr = rev.GetSubject() + L'\n' + rev.GetBody();
2712 }
2713
2714 if(this->m_bCommitAmend)
2715 {
2716 this->m_NoAmendStr=this->m_cLogMessage.GetText();
2717 m_cLogMessage.SetText(m_AmendStr);
2718 DialogEnableWindow(IDC_COMMIT_AMENDDIFF, m_bStagingSupport);
2719 GetDlgItem(IDC_COMMIT_AMENDDIFF)->ShowWindow(SW_SHOW);
2720 if (m_bStagingSupport)
2721 UpdateData(FALSE);
2722 if (m_bSetCommitDateTime)
2723 {
2724 m_AsCommitDateCtrl.EnableWindow(TRUE);
2725 m_AsCommitDateCtrl.ShowWindow(SW_SHOW);
2726 }
2727 }
2728 else
2729 {
2730 this->m_AmendStr=this->m_cLogMessage.GetText();
2731 m_cLogMessage.SetText(m_NoAmendStr);
2732 GetDlgItem(IDC_COMMIT_AMENDDIFF)->ShowWindow(SW_HIDE);
2733 DialogEnableWindow(IDC_COMMIT_AMENDDIFF, FALSE);
2734 m_AsCommitDateCtrl.ShowWindow(SW_HIDE);
2735 m_AsCommitDateCtrl.SetCheck(FALSE);
2736 m_AsCommitDateCtrl.EnableWindow(FALSE);
2737 OnBnClickedCommitAsCommitDate();
2738 }
2739
2740 OnBnClickedCommitSetDateTime(); // to update the commit date and time
2741 OnBnClickedCommitSetauthor(); // to update the commit author
2742
2743 GetDlgItem(IDC_LOGMESSAGE)->SetFocus();
2744 Refresh();
2745 }
2746
2747 void CCommitDlg::OnBnClickedCommitMessageOnly()
2748 {
2749 this->UpdateData();
2750 this->m_ListCtrl.EnableWindow(m_bCommitMessageOnly ? FALSE : TRUE);
2751 SendMessage(WM_UPDATEOKBUTTON);
2752 }
2753
2754 void CCommitDlg::OnBnClickedWholeProject()
2755 {
2756 m_tooltips.Pop(); // hide the tooltips
2757 UpdateData();
2758 m_ListCtrl.Clear();
2759 if (!m_bBlock)
2760 {
2761 if (m_bWholeProject || m_bWholeProject2)
2762 m_ListCtrl.GetStatus(nullptr, true, false, true, false, false, m_bStagingSupport);
2763 else
2764 m_ListCtrl.GetStatus(&this->m_pathList, true, false, true, false, false, m_bStagingSupport);
2765
2766 m_regShowWholeProject = m_bWholeProject;
2767
2768 DWORD dwShow = m_ListCtrl.GetShowFlags();
2769 if (DWORD(m_regAddBeforeCommit))
2770 dwShow |= GITSLC_SHOWUNVERSIONED;
2771 else
2772 dwShow &= ~GITSLC_SHOWUNVERSIONED;
2773
2774 m_ListCtrl.StoreScrollPos();
2775 m_ListCtrl.Show(dwShow, dwShow & ~(CTGitPath::LOGACTIONS_UNVER), true);
2776 UpdateCheckLinks();
2777 }
2778
2779 SetDlgTitle();
2780 }
2781
2782 void CCommitDlg::OnFocusMessage()
2783 {
2784 m_cLogMessage.SetFocus();
2785 }
2786
2787 void CCommitDlg::OnFocusFileList()
2788 {
2789 m_ListCtrl.SetFocus();
2790 }
2791
2792 void CCommitDlg::OnScnUpdateUI(NMHDR * /*pNMHDR*/, LRESULT *pResult)
2793 {
2794 auto pos = static_cast<Sci_Position>(m_cLogMessage.Call(SCI_GETCURRENTPOS));
2795 auto line = static_cast<int>(m_cLogMessage.Call(SCI_LINEFROMPOSITION, pos));
2796 auto column = static_cast<int>(m_cLogMessage.Call(SCI_GETCOLUMN, pos));
2797
2798 CString str;
2799 str.Format(L"%d/%d", line + 1, column + 1);
2800 this->GetDlgItem(IDC_TEXT_INFO)->SetWindowText(str);
2801
2802 if(*pResult)
2803 *pResult=0;
2804 }
2805
2806 void CCommitDlg::TogglePatchView()
2807 {
2808 DestroyPatchViewDlgIfOpen();
2809 if (m_bStagingSupport)
2810 {
2811 ShowPartialStagingTextAndUpdateDisplayState(true);
2812 ShowPartialUnstagingTextAndUpdateDisplayState(true);
2813 }
2814 else
2815 ShowViewPatchText(true);
2816 }
2817
2818 void CCommitDlg::OnStnClickedViewPatch()
2819 {
2820 if (IsWindow(this->m_patchViewdlg.m_hWnd))
2821 {
2822 DestroyPatchViewDlgIfOpen();
2823 ShowViewPatchText(true);
2824 }
2825 else
2826 {
2827 CreatePatchViewDlg();
2828 ShowViewPatchText(false);
2829 FillPatchView();
2830 }
2831 }
2832
2833 void CCommitDlg::OnStnClickedPartialStaging()
2834 {
2835 DestroyPatchViewDlgIfOpen();
2836 if (m_stagingDisplayState & SHOW_STAGING) // clicked Partial Staging, either with the patch window closed or open in Unstaging mode
2837 {
2838 CreatePatchViewDlg();
2839 m_patchViewdlg.SetWindowText(CString(MAKEINTRESOURCE(IDS_VIEWPATCH_INDEX_WORKTREE)));
2840 ShowPartialStagingTextAndUpdateDisplayState(false); // change "Partial Staging" to "Hide Staging"
2841 ShowPartialUnstagingTextAndUpdateDisplayState(true); // show "Partial Unstaging"
2842 FillPatchView(); // this needs to be called after the two calls to ShowPartial..... above
2843 }
2844 else // clicked Hide Staging
2845 {
2846 ShowPartialStagingTextAndUpdateDisplayState(true); // change "Hide Staging" to "Partial Staging"
2847 ShowPartialUnstagingTextAndUpdateDisplayState(true); // show "Partial Unstaging"
2848 }
2849 }
2850
2851 void CCommitDlg::OnStnClickedPartialUnstaging()
2852 {
2853 DestroyPatchViewDlgIfOpen();
2854 if (m_stagingDisplayState & SHOW_UNSTAGING) // clicked Partial Unstaging, either with the patch window closed or open in Staging mode
2855 {
2856 CreatePatchViewDlg();
2857 m_patchViewdlg.SetWindowText(CString(MAKEINTRESOURCE(IDS_VIEWPATCH_HEAD_INDEX)));
2858 ShowPartialUnstagingTextAndUpdateDisplayState(false); // change "Partial Unstaging" to "Hide Unstaging"
2859 ShowPartialStagingTextAndUpdateDisplayState(true); // show "Partial Staging"
2860 FillPatchView(); // this needs to be called after the two calls to ShowPartial..... above
2861 }
2862 else // clicked Hide Unstaging
2863 {
2864 ShowPartialUnstagingTextAndUpdateDisplayState(true); // change "Hide Unstaging" to "Partial Unstaging"
2865 ShowPartialStagingTextAndUpdateDisplayState(true); // show "Partial Staging"
2866 }
2867 }
2868
2869 void CCommitDlg::CreatePatchViewDlg()
2870 {
2871 m_patchViewdlg.m_ParentDlg = this;
2872 BOOL viewPatchEnabled = FALSE;
2873 viewPatchEnabled = g_Git.GetConfigValueBool(L"tgit.commitshowpatch");
2874 if (viewPatchEnabled == FALSE)
2875 g_Git.SetConfigValue(L"tgit.commitshowpatch", L"true");
2876 m_patchViewdlg.Create(IDD_PATCH_VIEW, this);
2877 m_patchViewdlg.ShowAndAlignToParent();
2878
2879 GetDlgItem(IDC_LOGMESSAGE)->SetFocus();
2880 }
2881
2882 void CCommitDlg::DestroyPatchViewDlgIfOpen()
2883 {
2884 if (IsWindow(this->m_patchViewdlg.m_hWnd))
2885 {
2886 g_Git.SetConfigValue(L"tgit.commitshowpatch", L"false");
2887 m_patchViewdlg.ShowWindow(SW_HIDE);
2888 m_patchViewdlg.EnableWindow(FALSE);
2889 m_patchViewdlg.DestroyWindow();
2890 }
2891 }
2892
2893 void CCommitDlg::OnMoving(UINT fwSide, LPRECT pRect)
2894 {
2895 __super::OnMoving(fwSide, pRect);
2896
2897 m_patchViewdlg.ParentOnMoving(m_hWnd, pRect);
2898 }
2899
2900 void CCommitDlg::OnSizing(UINT fwSide, LPRECT pRect)
2901 {
2902 __super::OnSizing(fwSide, pRect);
2903
2904 m_patchViewdlg.ParentOnSizing(m_hWnd, pRect);
2905 }
2906
2907 void CCommitDlg::OnHdnItemchangedFilelist(NMHDR * /*pNMHDR*/, LRESULT *pResult)
2908 {
2909 *pResult = 0;
2910 TRACE("Item Changed\r\n");
2911 }
2912
2913 int CCommitDlg::CheckHeadDetach()
2914 {
2915 CString output;
2916 if (CGit::GetCurrentBranchFromFile(g_Git.m_CurrentDir, output))
2917 {
2918 const int retval = CMessageBox::Show(GetSafeHwnd(), IDS_PROC_COMMIT_DETACHEDWARNING, IDS_APPNAME, MB_YESNOCANCEL | MB_ICONWARNING);
2919 if(retval == IDYES)
2920 {
2921 if (CAppUtils::CreateBranchTag(GetSafeHwnd(), FALSE, nullptr, true) == FALSE)
2922 return 1;
2923 }
2924 else if (retval == IDCANCEL)
2925 return 1;
2926 }
2927 return 0;
2928 }
2929
2930 void CCommitDlg::OnBnClickedCommitAmenddiff()
2931 {
2932 UpdateData();
2933 Refresh();
2934 }
2935
2936 void CCommitDlg::OnBnClickedNoautoselectsubmodules()
2937 {
2938 UpdateData();
2939 Refresh();
2940 }
2941
2942 void CCommitDlg::OnBnClickedCommitSetDateTime()
2943 {
2944 UpdateData();
2945
2946 if (m_bSetCommitDateTime)
2947 {
2948 CTime authordate = CTime::GetCurrentTime();
2949 if (m_bCommitAmend)
2950 {
2951 GitRev headRevision;
2952 if (headRevision.GetCommit(L"HEAD"))
2953 MessageBox(headRevision.GetLastErr(), L"TortoiseGit", MB_ICONERROR);
2954 authordate = headRevision.GetAuthorDate();
2955 m_AsCommitDateCtrl.EnableWindow(TRUE);
2956 m_AsCommitDateCtrl.ShowWindow(SW_SHOW);
2957 }
2958
2959 m_CommitDate.SetTime(&authordate);
2960 m_CommitTime.SetTime(&authordate);
2961
2962 GetDlgItem(IDC_COMMIT_DATEPICKER)->ShowWindow(SW_SHOW);
2963 GetDlgItem(IDC_COMMIT_TIMEPICKER)->ShowWindow(SW_SHOW);
2964 }
2965 else
2966 {
2967 GetDlgItem(IDC_COMMIT_DATEPICKER)->ShowWindow(SW_HIDE);
2968 GetDlgItem(IDC_COMMIT_TIMEPICKER)->ShowWindow(SW_HIDE);
2969 m_AsCommitDateCtrl.ShowWindow(SW_HIDE);
2970 m_AsCommitDateCtrl.EnableWindow(FALSE);
2971 m_AsCommitDateCtrl.SetCheck(FALSE);
2972 OnBnClickedCommitAsCommitDate();
2973 }
2974 }
2975
2976 void CCommitDlg::OnBnClickedCommitAsCommitDate()
2977 {
2978 GetDlgItem(IDC_COMMIT_DATEPICKER)->EnableWindow(!m_AsCommitDateCtrl.GetCheck());
2979 GetDlgItem(IDC_COMMIT_TIMEPICKER)->EnableWindow(!m_AsCommitDateCtrl.GetCheck());
2980 }
2981
2982 void CCommitDlg::OnBnClickedCheckNewBranch()
2983 {
2984 UpdateData();
2985 if (m_bCreateNewBranch)
2986 {
2987 GetDlgItem(IDC_COMMIT_TO)->ShowWindow(SW_HIDE);
2988 GetDlgItem(IDC_NEWBRANCH)->ShowWindow(SW_SHOW);
2989 GetDlgItem(IDC_NEWBRANCH)->SetFocus();
2990 GetDlgItem(IDC_NEWBRANCH)->SendMessage(EM_SETSEL, 0, -1);
2991 }
2992 else
2993 {
2994 GetDlgItem(IDC_NEWBRANCH)->ShowWindow(SW_HIDE);
2995 GetDlgItem(IDC_COMMIT_TO)->ShowWindow(SW_SHOW);
2996 }
2997 }
2998
2999 bool CCommitDlg::RestoreFiles(bool doNotAsk, bool allowCancel)
3000 {
3001 if (m_ListCtrl.m_restorepaths.empty())
3002 return true;
3003
3004 if (!doNotAsk)
3005 {
3006 auto ret = CMessageBox::Show(m_hWnd, IDS_PROC_COMMIT_RESTOREFILES, IDS_APPNAME, 2, IDI_QUESTION, IDS_PROC_COMMIT_RESTOREFILES_RESTORE, IDS_PROC_COMMIT_RESTOREFILES_KEEP, allowCancel ? IDS_MSGBOX_CANCEL : 0);
3007 if (ret == 3)
3008 return false;
3009 if (ret == 2)
3010 return true;
3011 }
3012
3013 for (const auto& item : m_ListCtrl.m_restorepaths)
3014 {
3015 CString dest = g_Git.CombinePath(item.first);
3016 CopyFile(item.second, dest, FALSE);
3017 CPathUtils::Touch(dest);
3018 }
3019 m_ListCtrl.m_restorepaths.clear();
3020
3021 return true;
3022 }
3023
3024 void CCommitDlg::UpdateCheckLinks()
3025 {
3026 DialogEnableWindow(IDC_CHECKALL, true);
3027 DialogEnableWindow(IDC_CHECKNONE, true);
3028 DialogEnableWindow(IDC_CHECKUNVERSIONED, m_ListCtrl.GetUnversionedCount() > 0);
3029 DialogEnableWindow(IDC_CHECKVERSIONED, m_ListCtrl.GetItemCount() > m_ListCtrl.GetUnversionedCount());
3030 DialogEnableWindow(IDC_CHECKADDED, m_ListCtrl.GetAddedCount() > 0);
3031 DialogEnableWindow(IDC_CHECKDELETED, m_ListCtrl.GetDeletedCount() > 0);
3032 DialogEnableWindow(IDC_CHECKMODIFIED, m_ListCtrl.GetModifiedCount() > 0);
3033 DialogEnableWindow(IDC_CHECKFILES, m_ListCtrl.GetFileCount() > 0);
3034 DialogEnableWindow(IDC_CHECKSUBMODULES, m_ListCtrl.GetSubmoduleCount() > 0);
3035 }
3036
3037 void CCommitDlg::OnBnClickedCommitSetauthor()
3038 {
3039 UpdateData();
3040
3041 GetDlgItem(IDC_COMMIT_AUTHORDATA)->SendMessage(EM_SETREADONLY, m_bSetAuthor ? FALSE: TRUE);
3042
3043 m_sAuthor.Format(L"%s <%s>", static_cast<LPCWSTR>(g_Git.GetUserName()), static_cast<LPCWSTR>(g_Git.GetUserEmail()));
3044 if (m_bCommitAmend)
3045 {
3046 GitRev headRevision;
3047 if (headRevision.GetCommit(L"HEAD"))
3048 MessageBox(headRevision.GetLastErr(), L"TortoiseGit", MB_ICONERROR);
3049 else
3050 m_sAuthor.Format(L"%s <%s>", static_cast<LPCWSTR>(headRevision.GetAuthorName()), static_cast<LPCWSTR>(headRevision.GetAuthorEmail()));
3051 }
3052 UpdateData(FALSE);
3053 }
3054
3055 void CCommitDlg::PrepareStagingSupport()
3056 {
3057 DestroyPatchViewDlgIfOpen();
3058 g_Git.SetConfigValue(L"tgit.commitstagingsupport", m_bStagingSupport ? L"true" : L"false");
3059 m_ListCtrl.EnableThreeStateCheckboxes(m_bStagingSupport);
3060 if (m_bStagingSupport)
3061 {
3062 if (m_bCommitAmend)
3063 {
3064 UpdateData(false);
3065 DialogEnableWindow(IDC_COMMIT_AMENDDIFF, false);
3066 }
3067 CMessageBox::ShowCheck(GetSafeHwnd(), IDS_TIPSTAGINGMODE, IDS_APPNAME, MB_ICONINFORMATION | MB_OK, L"HintStagingMode", IDS_MSGBOX_DONOTSHOWAGAIN);
3068 GetDlgItem(IDC_VIEW_PATCH)->ShowWindow(SW_HIDE);
3069 DialogEnableWindow(IDC_VIEW_PATCH, FALSE);
3070 ShowPartialStagingTextAndUpdateDisplayState(true);
3071 DialogEnableWindow(IDC_PARTIAL_STAGING, TRUE);
3072 GetDlgItem(IDC_PARTIAL_STAGING)->ShowWindow(SW_SHOW);
3073 ShowPartialUnstagingTextAndUpdateDisplayState(true);
3074 DialogEnableWindow(IDC_PARTIAL_UNSTAGING, TRUE);
3075 GetDlgItem(IDC_PARTIAL_UNSTAGING)->ShowWindow(SW_SHOW);
3076 }
3077 else
3078 {
3079 ShowViewPatchText(true);
3080 DialogEnableWindow(IDC_VIEW_PATCH, TRUE);
3081 GetDlgItem(IDC_VIEW_PATCH)->ShowWindow(SW_SHOW);
3082 GetDlgItem(IDC_PARTIAL_STAGING)->ShowWindow(SW_HIDE);
3083 DialogEnableWindow(IDC_PARTIAL_STAGING, FALSE);
3084 GetDlgItem(IDC_PARTIAL_UNSTAGING)->ShowWindow(SW_HIDE);
3085 DialogEnableWindow(IDC_PARTIAL_UNSTAGING, FALSE);
3086 }
3087 }
3088
3089 void CCommitDlg::OnBnClickedStagingSupport()
3090 {
3091 UpdateData();
3092 PrepareStagingSupport();
3093 Refresh();
3094 }
3095
3096 bool CCommitDlg::RunStartCommitHook()
3097 {
3098 DWORD exitcode = 0xFFFFFFFF;
3099 CString error;
3100 CHooks::Instance().SetProjectProperties(g_Git.m_CurrentDir, m_ProjectProperties);
3101 if (CHooks::Instance().StartCommit(GetSafeHwnd(), g_Git.m_CurrentDir, m_pathList, m_sLogMessage, exitcode, error))
3102 {
3103 if (exitcode)
3104 {
3105 CString sErrorMsg;
3106 sErrorMsg.Format(IDS_HOOK_ERRORMSG, static_cast<LPCWSTR>(error));
3107
3108 CTaskDialog taskdlg(sErrorMsg, CString(MAKEINTRESOURCE(IDS_HOOKFAILED_TASK2)), L"TortoiseGit", 0, TDF_ENABLE_HYPERLINKS | TDF_USE_COMMAND_LINKS | TDF_ALLOW_DIALOG_CANCELLATION | TDF_POSITION_RELATIVE_TO_WINDOW | TDF_SIZE_TO_CONTENT);
3109 taskdlg.AddCommandControl(101, CString(MAKEINTRESOURCE(IDS_HOOKFAILED_TASK3)));
3110 taskdlg.AddCommandControl(102, CString(MAKEINTRESOURCE(IDS_HOOKFAILED_TASK4)));
3111 taskdlg.SetDefaultCommandControl(101);
3112 taskdlg.SetMainIcon(TD_ERROR_ICON);
3113 if (taskdlg.DoModal(GetSafeHwnd()) != 102)
3114 return false;
3115 }
3116 }
3117 return true;
3118 }
Windows Explorer Extension to Operate Git