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