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