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