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