?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Don't import ogdf namespace
[TortoiseGit.git] / src / TortoiseProc / SyncDlg.cpp
blobde537231ac621394cd32c3a558fe45de2fd7eccc
1 // TortoiseGit - a Windows shell extension for easy version control
2
3 // Copyright (C) 2008-2018 - TortoiseGit
4
5 // This program is free software; you can redistribute it and/or
6 // modify it under the terms of the GNU General Public License
7 // as published by the Free Software Foundation; either version 2
8 // of the License, or (at your option) any later version.
9
10 // This program is distributed in the hope that it will be useful,
11 // but WITHOUT ANY WARRANTY; without even the implied warranty of
12 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
13 // GNU General Public License for more details.
14
15 // You should have received a copy of the GNU General Public License
16 // along with this program; if not, write to the Free Software Foundation,
17 // 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
18 //
19
20 // SyncDlg.cpp : implementation file
21 //
22
23 #include "stdafx.h"
24 #include "TortoiseProc.h"
25 #include "SyncDlg.h"
26 #include "AppUtils.h"
27 #include "ProgressDlg.h"
28 #include "MessageBox.h"
29 #include "ImportPatchDlg.h"
30 #include "RebaseDlg.h"
31 #include "Hooks.h"
32 #include "SmartHandle.h"
33 #include "ProgressCommands/FetchProgressCommand.h"
34 #include "SyncTabCtrl.h"
35 #include "SysProgressDlg.h"
36
37 // CSyncDlg dialog
38
39 IMPLEMENT_DYNAMIC(CSyncDlg, CResizableStandAloneDialog)
40
41 CSyncDlg::CSyncDlg(CWnd* pParent /*=nullptr*/)
42 : CResizableStandAloneDialog(CSyncDlg::IDD, pParent)
43 , m_iPullRebase(0)
44 , m_CurrentCmd(0)
45 , m_bInited(false)
46 , m_CmdOutCurrentPos(0)
47 , m_bAutoLoadPuttyKey(CAppUtils::IsSSHPutty())
48 , m_bForce(BST_UNCHECKED)
49 , m_bBlock(false)
50 , m_BufStart(0)
51 , m_pThread(nullptr)
52 , m_bAbort(false)
53 , m_bDone(false)
54 , m_bWantToExit(false)
55 , m_GitCmdStatus(-1)
56 , m_startTick(GetTickCount64())
57 , m_seq(0)
58 {
59 m_pTooltip = &m_tooltips;
60 }
61
62 CSyncDlg::~CSyncDlg()
63 {
64 }
65
66 void CSyncDlg::DoDataExchange(CDataExchange* pDX)
67 {
68 CDialog::DoDataExchange(pDX);
69 DDX_Check(pDX, IDC_CHECK_PUTTY_KEY, m_bAutoLoadPuttyKey);
70 DDX_Check(pDX, IDC_CHECK_FORCE,m_bForce);
71 DDX_Control(pDX, IDC_COMBOBOXEX_URL, m_ctrlURL);
72 DDX_Control(pDX, IDC_BUTTON_TABCTRL, m_ctrlDumyButton);
73 DDX_Control(pDX, IDC_BUTTON_PULL, m_ctrlPull);
74 DDX_Control(pDX, IDC_BUTTON_PUSH, m_ctrlPush);
75 DDX_Control(pDX, IDC_STATIC_STATUS, m_ctrlStatus);
76 DDX_Control(pDX, IDC_PROGRESS_SYNC, m_ctrlProgress);
77 DDX_Control(pDX, IDC_ANIMATE_SYNC, m_ctrlAnimate);
78 DDX_Control(pDX, IDC_BUTTON_SUBMODULE,m_ctrlSubmodule);
79 DDX_Control(pDX, IDC_BUTTON_STASH, m_ctrlStash);
80 DDX_Control(pDX, IDC_PROG_LABEL, m_ctrlProgLabel);
81 BRANCH_COMBOX_DDX;
82 }
83
84 BEGIN_MESSAGE_MAP(CSyncDlg, CResizableStandAloneDialog)
85 ON_BN_CLICKED(IDC_BUTTON_PULL, &CSyncDlg::OnBnClickedButtonPull)
86 ON_BN_CLICKED(IDC_BUTTON_PUSH, &CSyncDlg::OnBnClickedButtonPush)
87 ON_BN_CLICKED(IDC_BUTTON_APPLY, &CSyncDlg::OnBnClickedButtonApply)
88 ON_BN_CLICKED(IDC_BUTTON_EMAIL, &CSyncDlg::OnBnClickedButtonEmail)
89 ON_BN_CLICKED(IDC_BUTTON_MANAGE, &CSyncDlg::OnBnClickedButtonManage)
90 BRANCH_COMBOX_EVENT
91 ON_CBN_EDITCHANGE(IDC_COMBOBOXEX_URL, &CSyncDlg::OnCbnEditchangeComboboxex)
92 ON_CBN_EDITCHANGE(IDC_COMBOBOXEX_REMOTE_BRANCH, &CSyncDlg::OnCbnEditchangeComboboxex)
93 ON_MESSAGE(MSG_PROGRESSDLG_UPDATE_UI, OnProgressUpdateUI)
94 ON_MESSAGE(WM_PROG_CMD_FINISH, OnProgCmdFinish)
95 ON_BN_CLICKED(IDC_BUTTON_COMMIT, &CSyncDlg::OnBnClickedButtonCommit)
96 ON_BN_CLICKED(IDC_BUTTON_SUBMODULE, &CSyncDlg::OnBnClickedButtonSubmodule)
97 ON_BN_CLICKED(IDC_BUTTON_STASH, &CSyncDlg::OnBnClickedButtonStash)
98 ON_WM_TIMER()
99 ON_REGISTERED_MESSAGE(TaskBarButtonCreated, OnTaskbarBtnCreated)
100 ON_BN_CLICKED(IDC_CHECK_FORCE, &CSyncDlg::OnBnClickedCheckForce)
101 ON_BN_CLICKED(IDC_LOG, &CSyncDlg::OnBnClickedLog)
102 ON_WM_DESTROY()
103 ON_WM_THEMECHANGED()
104 END_MESSAGE_MAP()
105
106 void CSyncDlg::EnableControlButton(bool bEnabled)
107 {
108 GetDlgItem(IDC_BUTTON_PULL)->EnableWindow(bEnabled);
109 GetDlgItem(IDC_BUTTON_PUSH)->EnableWindow(bEnabled);
110 GetDlgItem(IDC_BUTTON_APPLY)->EnableWindow(bEnabled);
111 GetDlgItem(IDC_BUTTON_EMAIL)->EnableWindow(bEnabled);
112 GetDlgItem(IDOK)->EnableWindow(bEnabled);
113 GetDlgItem(IDC_BUTTON_SUBMODULE)->EnableWindow(bEnabled);
114 GetDlgItem(IDC_BUTTON_STASH)->EnableWindow(bEnabled);
115 }
116 // CSyncDlg message handlers
117
118 bool CSyncDlg::AskSetTrackedBranch()
119 {
120 CString remote, remoteBranch;
121 g_Git.GetRemoteTrackedBranch(m_strLocalBranch, remote, remoteBranch);
122 if (remoteBranch.IsEmpty())
123 {
124 remoteBranch = m_strRemoteBranch;
125 if (remoteBranch.IsEmpty())
126 remoteBranch = m_strLocalBranch;
127 CString temp;
128 temp.FormatMessage(IDS_NOTYET_SETTRACKEDBRANCH, (LPCTSTR)m_strLocalBranch, (LPCTSTR)remoteBranch);
129 BOOL dontShowAgain = FALSE;
130 auto ret = CMessageBox::ShowCheck(GetSafeHwnd(), temp, L"TortoiseGit", MB_ICONQUESTION | MB_YESNOCANCEL, nullptr, CString(MAKEINTRESOURCE(IDS_MSGBOX_DONOTSHOW)), &dontShowAgain);
131 if (dontShowAgain)
132 CRegDWORD(L"Software\\TortoiseGit\\AskSetTrackedBranch") = FALSE;
133 if (ret == IDCANCEL)
134 return false;
135 if (ret == IDYES)
136 {
137 CString key;
138 key.Format(L"branch.%s.remote", (LPCTSTR)m_strLocalBranch);
139 g_Git.SetConfigValue(key, m_strURL);
140 key.Format(L"branch.%s.merge", (LPCTSTR)m_strLocalBranch);
141 g_Git.SetConfigValue(key, L"refs/heads/" + g_Git.StripRefName(remoteBranch));
142 }
143 }
144 return true;
145 }
146
147 void CSyncDlg::OnBnClickedButtonPull()
148 {
149 bool bShift = (GetAsyncKeyState(VK_SHIFT) & 0x8000) != 0;
150
151 int CurrentEntry;
152 CurrentEntry = (int)this->m_ctrlPull.GetCurrentEntry();
153 this->m_regPullButton = CurrentEntry;
154
155 if (bShift && CurrentEntry > 1)
156 return;
157
158 this->m_bAbort=false;
159 this->m_GitCmdList.clear();
160 m_ctrlCmdOut.SetWindowText(L"");
161 m_LogText.Empty();
162
163 this->UpdateData();
164 UpdateCombox();
165
166 if (g_Git.GetHash(m_oldHash, L"HEAD"))
167 {
168 MessageBox(g_Git.GetGitLastErr(L"Could not get HEAD hash."), L"TortoiseGit", MB_ICONERROR);
169 return;
170 }
171
172 m_refList.Clear();
173 m_newHashMap.clear();
174 m_oldHashMap.clear();
175
176 if( CurrentEntry == 0)
177 {
178 CGitHash localBranchHash;
179 if (g_Git.GetHash(localBranchHash, m_strLocalBranch))
180 {
181 MessageBox(g_Git.GetGitLastErr(L"Could not get hash of \"" + m_strLocalBranch + L"\"."), L"TortoiseGit", MB_ICONERROR);
182 return;
183 }
184 if (localBranchHash != m_oldHash)
185 {
186 CMessageBox::Show(GetSafeHwnd(), IDS_PROC_SYNC_PULLWRONGBRANCH, IDS_APPNAME, MB_OK | MB_ICONERROR);
187 return;
188 }
189 }
190
191 if(this->m_strURL.IsEmpty())
192 {
193 CMessageBox::Show(GetSafeHwnd(), IDS_PROC_GITCONFIG_URLEMPTY, IDS_APPNAME, MB_OK | MB_ICONERROR);
194 return;
195 }
196
197 if (CurrentEntry == 6)
198 {
199 SwitchToRun();
200 m_ctrlTabCtrl.ShowTab(IDC_LOG - 1, false);
201 m_ctrlTabCtrl.ShowTab(IDC_REFLIST - 1, false);
202 m_ctrlTabCtrl.ShowTab(IDC_OUT_LOGLIST - 1, false);
203 m_ctrlTabCtrl.ShowTab(IDC_OUT_CHANGELIST - 1, false);
204 m_ctrlTabCtrl.ShowTab(IDC_IN_LOGLIST - 1, false);
205 m_ctrlTabCtrl.ShowTab(IDC_IN_CHANGELIST - 1, false);
206 m_ctrlTabCtrl.ShowTab(IDC_IN_CONFLICT - 1, false);
207 m_ctrlTabCtrl.ShowTab(IDC_TAGCOMPARELIST - 1, true);
208
209 CSysProgressDlg sysProgressDlg;
210 sysProgressDlg.SetTitle(CString(MAKEINTRESOURCE(IDS_APPNAME)));
211 sysProgressDlg.SetLine(1, CString(MAKEINTRESOURCE(IDS_LOADING)));
212 sysProgressDlg.SetLine(2, CString(MAKEINTRESOURCE(IDS_PROGRESSWAIT)));
213 sysProgressDlg.SetShowProgressBar(false);
214 sysProgressDlg.ShowModal(this, true);
215 CString err;
216 auto ret = m_tagCompareList.Fill(m_strURL, err);
217 sysProgressDlg.Stop();
218 if (ret)
219 MessageBox(err, L"TortoiseGit", MB_ICONERROR);
220
221 BringWindowToTop();
222 SwitchToInput();
223 EnableControlButton();
224 return;
225 }
226
227 if (!IsURL() && !m_strRemoteBranch.IsEmpty() && CurrentEntry == 0 && CRegDWORD(L"Software\\TortoiseGit\\AskSetTrackedBranch", TRUE) == TRUE)
228 {
229 if (!AskSetTrackedBranch())
230 return;
231 }
232
233 if (m_bAutoLoadPuttyKey && CurrentEntry != 4) // CurrentEntry (Remote Update) handles this on its own)
234 {
235 CAppUtils::LaunchPAgent(this->GetSafeHwnd(), nullptr, &m_strURL);
236 }
237
238 if (g_Git.GetMapHashToFriendName(m_oldHashMap))
239 MessageBox(g_Git.GetGitLastErr(L"Could not get all refs."), L"TortoiseGit", MB_ICONERROR);
240
241 if (bShift && (CurrentEntry == 0 || CurrentEntry == 1))
242 {
243 if (CurrentEntry == 1 || CurrentEntry == 2 || CurrentEntry == 3)
244 CAppUtils::Fetch(GetSafeHwnd(), !IsURL() ? m_strURL : L"");
245 else
246 CAppUtils::Pull(GetSafeHwnd());
247
248 FillNewRefMap();
249 FetchOutList(true);
250
251 int hasConflicts = g_Git.HasWorkingTreeConflicts();
252 if (hasConflicts < 0)
253 {
254 this->m_ctrlCmdOut.SetSel(-1, -1);
255 this->m_ctrlCmdOut.ReplaceSel(g_Git.GetGitLastErr(L"Checking for conflicts failed.", CGit::GIT_CMD_CHECKCONFLICTS));
256
257 this->ShowTab(IDC_CMD_LOG);
258 return;
259 }
260
261 if (hasConflicts)
262 {
263 this->m_ConflictFileList.Clear();
264 this->m_ConflictFileList.GetStatus(nullptr, true);
265 this->m_ConflictFileList.Show(CTGitPath::LOGACTIONS_UNMERGED,
266 CTGitPath::LOGACTIONS_UNMERGED);
267
268 this->ShowTab(IDC_IN_CONFLICT);
269 CMessageBox::ShowCheck(GetSafeHwnd(), IDS_NEED_TO_RESOLVE_CONFLICTS_HINT, IDS_APPNAME, MB_ICONINFORMATION, L"MergeConflictsNeedsCommit", IDS_MSGBOX_DONOTSHOWAGAIN);
270 }
271 else
272 ShowInCommits(L"HEAD");
273
274 return;
275 }
276
277 CString force;
278 if(this->m_bForce)
279 force = L" --force";
280
281 CString cmd;
282
283 m_iPullRebase = 0;
284 if (CurrentEntry == 0) // check whether we need to override Pull if pull.rebase is set
285 {
286 CAutoRepository repo(g_Git.GetGitRepository());
287 if (!repo)
288 MessageBox(CGit::GetLibGit2LastErr(L"Could not open repository."), L"TortoiseGit", MB_OK | MB_ICONERROR);
289
290 // Check config branch.<name>.rebase and pull.reabse
291 do
292 {
293 if (!repo)
294 break;
295
296 if (git_repository_head_detached(repo) == 1)
297 break;
298
299 CAutoConfig config(true);
300 if (git_repository_config(config.GetPointer(), repo))
301 break;
302
303 // branch.<name>.rebase overrides pull.rebase
304 if (config.GetBOOL(L"branch." + g_Git.GetCurrentBranch() + L".rebase", m_iPullRebase) == GIT_ENOTFOUND)
305 {
306 if (config.GetBOOL(L"pull.rebase", m_iPullRebase) == GIT_ENOTFOUND)
307 break;
308 else
309 {
310 CString value;
311 config.GetString(L"pull.rebase", value);
312 if (value == L"preserve")
313 {
314 m_iPullRebase = 2;
315 break;
316 }
317 }
318 }
319 else
320 {
321 CString value;
322 config.GetString(L"branch." + g_Git.GetCurrentBranch() + L".rebase", value);
323 if (value == L"preserve")
324 {
325 m_iPullRebase = 2;
326 break;
327 }
328 }
329 } while (0);
330 if (m_iPullRebase > 0)
331 {
332 CurrentEntry = 1;
333 if (m_strRemoteBranch.IsEmpty())
334 {
335 CMessageBox::Show(GetSafeHwnd(), IDS_PROC_PULL_EMPTYBRANCH, IDS_APPNAME, MB_ICONEXCLAMATION);
336 return;
337 }
338 }
339 }
340
341 SwitchToRun();
342
343 ShowTab(IDC_CMD_LOG);
344
345 m_ctrlTabCtrl.ShowTab(IDC_REFLIST - 1, true);
346 m_ctrlTabCtrl.ShowTab(IDC_IN_LOGLIST - 1, false);
347 m_ctrlTabCtrl.ShowTab(IDC_IN_CHANGELIST - 1, false);
348 m_ctrlTabCtrl.ShowTab(IDC_IN_CONFLICT - 1, false);
349 m_ctrlTabCtrl.ShowTab(IDC_TAGCOMPARELIST - 1, false);
350
351 ///Pull
352 if(CurrentEntry == 0) //Pull
353 {
354 CString remotebranch;
355 remotebranch = m_strRemoteBranch;
356
357 if(!IsURL())
358 {
359 CString pullRemote, pullBranch;
360 g_Git.GetRemoteTrackedBranch(m_strLocalBranch, pullRemote, pullBranch);
361 if(pullBranch == remotebranch && pullRemote == this->m_strURL)
362 remotebranch.Empty();
363 }
364
365 cmd.Format(L"git.exe pull -v --progress%s \"%s\" %s",
366 (LPCTSTR)force,
367 (LPCTSTR)m_strURL,
368 (LPCTSTR)remotebranch);
369
370 m_CurrentCmd = GIT_COMMAND_PULL;
371 m_GitCmdList.push_back(cmd);
372
373 m_pThread = AfxBeginThread(ProgressThreadEntry, this, THREAD_PRIORITY_NORMAL,0,CREATE_SUSPENDED);
374 if (!m_pThread)
375 {
376 // ReportError(CString(MAKEINTRESOURCE(IDS_ERR_THREADSTARTFAILED)));
377 }
378 else
379 {
380 m_pThread->m_bAutoDelete = TRUE;
381 m_pThread->ResumeThread();
382 }
383
384 }
385
386 ///Fetch
387 if (CurrentEntry == 1 || CurrentEntry == 2 || CurrentEntry == 3)
388 {
389 m_oldRemoteHash.Empty();
390 CString remotebranch;
391 if (CurrentEntry == 3)
392 m_strRemoteBranch.Empty();
393 else if (IsURL() || m_strRemoteBranch.IsEmpty())
394 {
395 remotebranch=this->m_strRemoteBranch;
396
397 }
398 else
399 {
400 remotebranch.Format(L"remotes/%s/%s", (LPCTSTR)m_strURL, (LPCTSTR)m_strRemoteBranch);
401 g_Git.GetHash(m_oldRemoteHash, remotebranch);
402 if (m_oldRemoteHash.IsEmpty())
403 remotebranch=m_strRemoteBranch;
404 else
405 remotebranch = m_strRemoteBranch + L':' + remotebranch;
406 }
407
408 if (CurrentEntry == 1 || CurrentEntry == 3)
409 m_CurrentCmd = GIT_COMMAND_FETCH;
410 else
411 m_CurrentCmd = GIT_COMMAND_FETCHANDREBASE;
412
413 if (g_Git.UsingLibGit2(CGit::GIT_CMD_FETCH))
414 {
415 CString refspec;
416 if (!remotebranch.IsEmpty())
417 refspec.Format(L"refs/heads/%s:refs/remotes/%s/%s", (LPCTSTR)m_strRemoteBranch, (LPCTSTR)m_strURL, (LPCTSTR)m_strRemoteBranch);
418
419 progressCommand = std::make_unique<FetchProgressCommand>();
420 FetchProgressCommand* fetchProgressCommand = static_cast<FetchProgressCommand*>(progressCommand.get());
421 fetchProgressCommand->SetUrl(m_strURL);
422 fetchProgressCommand->SetRefSpec(refspec);
423 m_GitProgressList.SetCommand(progressCommand.get());
424 m_GitProgressList.Init();
425 ShowTab(IDC_CMD_GIT_PROG);
426 }
427 else
428 {
429 cmd.Format(L"git.exe fetch --progress -v%s \"%s\" %s",
430 (LPCTSTR)force,
431 (LPCTSTR)m_strURL,
432 (LPCTSTR)remotebranch);
433
434 m_GitCmdList.push_back(cmd);
435
436 m_pThread = AfxBeginThread(ProgressThreadEntry, this, THREAD_PRIORITY_NORMAL,0,CREATE_SUSPENDED);
437 if (!m_pThread)
438 {
439 // ReportError(CString(MAKEINTRESOURCE(IDS_ERR_THREADSTARTFAILED)));
440 }
441 else
442 {
443 m_pThread->m_bAutoDelete = TRUE;
444 m_pThread->ResumeThread();
445 }
446 }
447 }
448
449 ///Remote Update
450 if (CurrentEntry == 4)
451 {
452 if (m_bAutoLoadPuttyKey)
453 {
454 for (size_t i = 0; i < m_remotelist.size(); ++i)
455 CAppUtils::LaunchPAgent(this->GetSafeHwnd(), nullptr, &m_remotelist[i]);
456 }
457
458 m_CurrentCmd = GIT_COMMAND_REMOTE;
459 cmd = L"git.exe remote update";
460 m_GitCmdList.push_back(cmd);
461
462 InterlockedExchange(&m_bBlock, TRUE);
463
464 m_pThread = AfxBeginThread(ProgressThreadEntry, this, THREAD_PRIORITY_NORMAL,0,CREATE_SUSPENDED);
465 if (!m_pThread)
466 {
467 // ReportError(CString(MAKEINTRESOURCE(IDS_ERR_THREADSTARTFAILED)));
468 InterlockedExchange(&m_bBlock, FALSE);
469 }
470 else
471 {
472 m_pThread->m_bAutoDelete = TRUE;
473 m_pThread->ResumeThread();
474 }
475 }
476
477 ///Cleanup stale remote banches
478 if (CurrentEntry == 5)
479 {
480 m_CurrentCmd = GIT_COMMAND_REMOTE;
481 cmd.Format(L"git.exe remote prune \"%s\"", (LPCTSTR)m_strURL);
482 m_GitCmdList.push_back(cmd);
483
484 InterlockedExchange(&m_bBlock, TRUE);
485
486 m_pThread = AfxBeginThread(ProgressThreadEntry, this, THREAD_PRIORITY_NORMAL,0,CREATE_SUSPENDED);
487 if (!m_pThread)
488 {
489 // ReportError(CString(MAKEINTRESOURCE(IDS_ERR_THREADSTARTFAILED)));
490 InterlockedExchange(&m_bBlock, FALSE);
491 }
492 else
493 {
494 m_pThread->m_bAutoDelete = TRUE;
495 m_pThread->ResumeThread();
496 }
497 }
498 }
499
500 void CSyncDlg::ShowInCommits(const CString& friendname)
501 {
502 CGitHash newHash;
503
504 if (g_Git.GetHash(newHash, friendname))
505 {
506 MessageBox(g_Git.GetGitLastErr(L"Could not get " + friendname + L" hash."), L"TortoiseGit", MB_ICONERROR);
507 return;
508 }
509
510 if (newHash == m_oldHash)
511 {
512 m_ctrlTabCtrl.ShowTab(IDC_IN_CHANGELIST - 1, false);
513 m_InLogList.ShowText(CString(MAKEINTRESOURCE(IDS_UPTODATE)));
514 m_ctrlTabCtrl.ShowTab(IDC_IN_LOGLIST - 1, true);
515 ShowTab(IDC_REFLIST);
516 }
517 else
518 {
519 m_ctrlTabCtrl.ShowTab(IDC_IN_CHANGELIST - 1, true);
520 m_ctrlTabCtrl.ShowTab(IDC_IN_LOGLIST - 1, true);
521
522 AddDiffFileList(&m_InChangeFileList, &m_arInChangeList, newHash.ToString(), m_oldHash.ToString());
523
524 CString range;
525 range.Format(L"%s..%s", (LPCTSTR)m_oldHash.ToString(), (LPCTSTR)newHash.ToString());
526 m_InLogList.FillGitLog(nullptr, &range, CGit::LOG_INFO_STAT | CGit::LOG_INFO_FILESTATE | CGit::LOG_INFO_SHOW_MERGEDFILE);
527 ShowTab(IDC_IN_LOGLIST);
528 }
529 }
530
531 void CSyncDlg::PullComplete()
532 {
533 EnableControlButton(true);
534 SwitchToInput();
535 this->FetchOutList(true);
536
537 if( this ->m_GitCmdStatus )
538 {
539 int hasConflicts = g_Git.HasWorkingTreeConflicts();
540 if (hasConflicts < 0)
541 {
542 this->m_ctrlCmdOut.SetSel(-1,-1);
543 this->m_ctrlCmdOut.ReplaceSel(g_Git.GetGitLastErr(L"Checking for conflicts failed.", CGit::GIT_CMD_CHECKCONFLICTS));
544
545 this->ShowTab(IDC_CMD_LOG);
546 return;
547 }
548
549 if (hasConflicts)
550 {
551 this->m_ConflictFileList.Clear();
552 this->m_ConflictFileList.GetStatus(nullptr, true);
553 this->m_ConflictFileList.Show(CTGitPath::LOGACTIONS_UNMERGED,
554 CTGitPath::LOGACTIONS_UNMERGED);
555
556 this->ShowTab(IDC_IN_CONFLICT);
557 CMessageBox::ShowCheck(GetSafeHwnd(), IDS_NEED_TO_RESOLVE_CONFLICTS_HINT, IDS_APPNAME, MB_ICONINFORMATION, L"MergeConflictsNeedsCommit", IDS_MSGBOX_DONOTSHOWAGAIN);
558 }
559 else
560 this->ShowTab(IDC_CMD_LOG);
561
562 }
563 else
564 ShowInCommits(L"HEAD");
565 }
566
567 void CSyncDlg::FetchComplete()
568 {
569 EnableControlButton(true);
570 SwitchToInput();
571
572 if (g_Git.UsingLibGit2(CGit::GIT_CMD_FETCH))
573 ShowTab(IDC_CMD_GIT_PROG);
574 else
575 ShowTab(IDC_REFLIST);
576
577 if (m_GitCmdStatus || (m_CurrentCmd != GIT_COMMAND_FETCHANDREBASE && m_iPullRebase == 0))
578 {
579 FetchOutList(true);
580 return;
581 }
582
583 CString remote;
584 CString remotebranch;
585 CString upstream = L"FETCH_HEAD";
586 m_ctrlURL.GetWindowText(remote);
587 if (!remote.IsEmpty())
588 {
589 if (std::find(m_remotelist.cbegin(), m_remotelist.cend(), remote) == m_remotelist.cend())
590 remote.Empty();
591 }
592 m_ctrlRemoteBranch.GetWindowText(remotebranch);
593 if (!remote.IsEmpty() && !remotebranch.IsEmpty())
594 upstream = L"remotes/" + remote + L'/' + remotebranch;
595
596 if (m_iPullRebase > 0)
597 {
598 CAppUtils::RebaseAfterFetch(GetSafeHwnd(), upstream, m_iPullRebase ? 2 : 0, m_iPullRebase == 2);
599 FillNewRefMap();
600 FetchOutList(true);
601
602 ShowInCommits(L"HEAD");
603
604 return;
605 }
606
607 CGitHash remoteBranchHash;
608 g_Git.GetHash(remoteBranchHash, upstream);
609 if (remoteBranchHash == m_oldRemoteHash && !m_oldRemoteHash.IsEmpty() && CMessageBox::ShowCheck(this->GetSafeHwnd(), IDS_REBASE_BRANCH_UNCHANGED, IDS_APPNAME, MB_ICONQUESTION | MB_YESNO | MB_DEFBUTTON2, L"OpenRebaseRemoteBranchUnchanged", IDS_MSGBOX_DONOTSHOWAGAIN) == IDNO)
610 {
611 ShowInCommits(upstream);
612 return;
613 }
614
615 if (g_Git.IsFastForward(L"HEAD", upstream))
616 {
617 UINT ret = CMessageBox::ShowCheck(GetSafeHwnd(), IDS_REBASE_BRANCH_FF, IDS_APPNAME, 2, IDI_QUESTION, IDS_MERGEBUTTON, IDS_REBASEBUTTON, IDS_ABORTBUTTON, L"OpenRebaseRemoteBranchFastForwards", IDS_MSGBOX_DONOTSHOWAGAIN);
618 if (ret == 3)
619 return;
620 if (ret == 1)
621 {
622 CProgressDlg mergeProgress;
623 mergeProgress.m_GitCmd = L"git.exe merge --ff-only " + upstream;
624 mergeProgress.m_AutoClose = AUTOCLOSE_IF_NO_ERRORS;
625 mergeProgress.m_PostCmdCallback = [](DWORD status, PostCmdList& postCmdList)
626 {
627 if (status && g_Git.HasWorkingTreeConflicts())
628 {
629 // there are conflict files
630 postCmdList.emplace_back(IDI_RESOLVE, IDS_PROGRS_CMD_RESOLVE, []
631 {
632 CString sCmd;
633 sCmd.Format(L"/command:commit /path:\"%s\"", (LPCTSTR)g_Git.m_CurrentDir);
634 CAppUtils::RunTortoiseGitProc(sCmd);
635 });
636 }
637 };
638 mergeProgress.DoModal();
639 FillNewRefMap();
640 FetchOutList(true);
641
642 ShowInCommits(L"HEAD");
643
644 return;
645 }
646 }
647
648 CAppUtils::RebaseAfterFetch(GetSafeHwnd(), upstream);
649 FillNewRefMap();
650 FetchOutList(true);
651
652 ShowInCommits(L"HEAD");
653 }
654
655 void CSyncDlg::StashComplete()
656 {
657 EnableControlButton(true);
658 INT_PTR entry = m_ctrlStash.GetCurrentEntry();
659 if (entry != 1 && entry != 2)
660 return;
661
662 SwitchToInput();
663 if (m_GitCmdStatus)
664 {
665 int hasConflicts = g_Git.HasWorkingTreeConflicts();
666 if (hasConflicts < 0)
667 {
668 m_ctrlCmdOut.SetSel(-1, -1);
669 m_ctrlCmdOut.ReplaceSel(g_Git.GetGitLastErr(L"Checking for conflicts failed.", CGit::GIT_CMD_CHECKCONFLICTS));
670
671 ShowTab(IDC_CMD_LOG);
672 return;
673 }
674
675 if (hasConflicts)
676 {
677 m_ConflictFileList.Clear();
678 m_ConflictFileList.GetStatus(nullptr, true);
679 m_ConflictFileList.Show(CTGitPath::LOGACTIONS_UNMERGED, CTGitPath::LOGACTIONS_UNMERGED);
680
681 ShowTab(IDC_IN_CONFLICT);
682 }
683 else
684 ShowTab(IDC_CMD_LOG);
685 }
686 }
687
688 void CSyncDlg::OnBnClickedButtonPush()
689 {
690 bool bShift = (GetAsyncKeyState(VK_SHIFT) & 0x8000) != 0;
691 this->UpdateData();
692 UpdateCombox();
693
694 if (bShift)
695 {
696 if (m_ctrlPush.GetCurrentEntry() == 0)
697 {
698 CAppUtils::Push(GetSafeHwnd(), g_Git.FixBranchName(m_strLocalBranch));
699 FillNewRefMap();
700 FetchOutList(true);
701 }
702 return;
703 }
704
705 m_ctrlCmdOut.SetWindowText(L"");
706 m_LogText.Empty();
707
708 if(this->m_strURL.IsEmpty())
709 {
710 CMessageBox::Show(GetSafeHwnd(), IDS_PROC_GITCONFIG_URLEMPTY, IDS_APPNAME, MB_OK | MB_ICONERROR);
711 return;
712 }
713
714 if (!IsURL() && m_ctrlPush.GetCurrentEntry() == 0 && CRegDWORD(L"Software\\TortoiseGit\\AskSetTrackedBranch", TRUE) == TRUE)
715 {
716 if (!AskSetTrackedBranch())
717 return;
718 }
719
720 this->m_regPushButton=(DWORD)this->m_ctrlPush.GetCurrentEntry();
721 this->SwitchToRun();
722 this->m_bAbort=false;
723 this->m_GitCmdList.clear();
724
725 ShowTab(IDC_CMD_LOG);
726
727 CString cmd;
728 CString arg;
729
730 CString error;
731 DWORD exitcode = 0xFFFFFFFF;
732 if (CHooks::Instance().PrePush(g_Git.m_CurrentDir, exitcode, error))
733 {
734 if (exitcode)
735 {
736 CString temp;
737 temp.Format(IDS_ERR_HOOKFAILED, (LPCTSTR)error);
738 CMessageBox::Show(GetSafeHwnd(), temp, L"TortoiseGit", MB_OK | MB_ICONERROR);
739 return ;
740 }
741 }
742
743 CString refName = g_Git.FixBranchName(m_strLocalBranch);
744 switch (m_ctrlPush.GetCurrentEntry())
745 {
746 case 1:
747 arg += L" --tags";
748 break;
749 case 2:
750 refName = L"refs/notes/commits"; //default ref for notes
751 break;
752 }
753
754 if(this->m_bForce)
755 arg += L" --force";
756
757 cmd.Format(L"git.exe push -v --progress%s \"%s\" %s",
758 (LPCTSTR)arg,
759 (LPCTSTR)m_strURL,
760 (LPCTSTR)refName);
761
762 if (!m_strRemoteBranch.IsEmpty() && m_ctrlPush.GetCurrentEntry() != 2)
763 {
764 cmd += L':' + m_strRemoteBranch;
765 }
766
767 m_GitCmdList.push_back(cmd);
768
769 m_CurrentCmd = GIT_COMMAND_PUSH;
770
771 if(this->m_bAutoLoadPuttyKey)
772 {
773 CAppUtils::LaunchPAgent(this->GetSafeHwnd(), nullptr, &m_strURL);
774 }
775
776 m_pThread = AfxBeginThread(ProgressThreadEntry, this, THREAD_PRIORITY_NORMAL,0,CREATE_SUSPENDED);
777 if (!m_pThread)
778 {
779 // ReportError(CString(MAKEINTRESOURCE(IDS_ERR_THREADSTARTFAILED)));
780 }
781 else
782 {
783 m_pThread->m_bAutoDelete = TRUE;
784 m_pThread->ResumeThread();
785 }
786 }
787
788 void CSyncDlg::OnBnClickedButtonApply()
789 {
790 CGitHash oldhash;
791 if (g_Git.GetHash(oldhash, L"HEAD"))
792 {
793 MessageBox(g_Git.GetGitLastErr(L"Could not get HEAD hash."), L"TortoiseGit", MB_ICONERROR);
794 return;
795 }
796
797 CImportPatchDlg dlg;
798 CString cmd,output;
799
800 if(dlg.DoModal() == IDOK)
801 {
802 int err=0;
803 for (int i = 0; i < dlg.m_PathList.GetCount(); ++i)
804 {
805 cmd.Format(L"git.exe am \"%s\"", (LPCTSTR)dlg.m_PathList[i].GetGitPathString());
806
807 if (g_Git.Run(cmd, &output, CP_UTF8))
808 {
809 CMessageBox::Show(GetSafeHwnd(), output, L"TortoiseGit", MB_OK | MB_ICONERROR);
810
811 err=1;
812 break;
813 }
814 this->m_ctrlCmdOut.SetSel(-1,-1);
815 this->m_ctrlCmdOut.ReplaceSel(cmd + L'\n');
816 this->m_ctrlCmdOut.SetSel(-1,-1);
817 this->m_ctrlCmdOut.ReplaceSel(output);
818 }
819
820 CGitHash newhash;
821 if (g_Git.GetHash(newhash, L"HEAD"))
822 {
823 MessageBox(g_Git.GetGitLastErr(L"Could not get HEAD hash after applying patches."), L"TortoiseGit", MB_ICONERROR);
824 return;
825 }
826
827 this->m_InLogList.Clear();
828 this->m_InChangeFileList.Clear();
829
830 if(newhash == oldhash)
831 {
832 this->m_ctrlTabCtrl.ShowTab(IDC_IN_CHANGELIST-1,false);
833 this->m_InLogList.ShowText(L"No commits get from patch");
834 this->m_ctrlTabCtrl.ShowTab(IDC_IN_LOGLIST-1,true);
835
836 }
837 else
838 {
839 this->m_ctrlTabCtrl.ShowTab(IDC_IN_CHANGELIST-1,true);
840 this->m_ctrlTabCtrl.ShowTab(IDC_IN_LOGLIST-1,true);
841
842 CString range;
843 range.Format(L"%s..%s", (LPCTSTR)m_oldHash.ToString(), (LPCTSTR)newhash.ToString());
844 this->AddDiffFileList(&m_InChangeFileList, &m_arInChangeList, newhash.ToString(), oldhash.ToString());
845 m_InLogList.FillGitLog(nullptr, &range, CGit::LOG_INFO_STAT| CGit::LOG_INFO_FILESTATE | CGit::LOG_INFO_SHOW_MERGEDFILE);
846
847 this->FetchOutList(true);
848 }
849
850 this->m_ctrlTabCtrl.ShowTab(IDC_CMD_LOG-1,true);
851
852 if(err)
853 {
854 this->ShowTab(IDC_CMD_LOG);
855 }
856 else
857 {
858 this->ShowTab(IDC_IN_LOGLIST);
859 }
860 }
861 }
862
863 void CSyncDlg::OnBnClickedButtonEmail()
864 {
865 CString cmd, out, err;
866
867 this->m_strLocalBranch = this->m_ctrlLocalBranch.GetString();
868 this->m_ctrlRemoteBranch.GetWindowText(this->m_strRemoteBranch);
869 this->m_ctrlURL.GetWindowText(this->m_strURL);
870 m_strURL=m_strURL.Trim();
871 m_strRemoteBranch=m_strRemoteBranch.Trim();
872
873 cmd.Format(L"git.exe format-patch -o \"%s\" %s..%s",
874 (LPCTSTR)g_Git.m_CurrentDir,
875 (LPCTSTR)(m_strURL + L'/' + m_strRemoteBranch), (LPCTSTR)g_Git.FixBranchName(m_strLocalBranch));
876
877 if (g_Git.Run(cmd, &out, &err, CP_UTF8))
878 {
879 CMessageBox::Show(GetSafeHwnd(), out + L'\n' + err, L"TortoiseGit", MB_OK | MB_ICONERROR);
880 return ;
881 }
882
883 CAppUtils::SendPatchMail(GetSafeHwnd(), cmd, out);
884 }
885 void CSyncDlg::ShowProgressCtrl(bool bShow)
886 {
887 int b=bShow?SW_NORMAL:SW_HIDE;
888 this->m_ctrlAnimate.ShowWindow(b);
889 this->m_ctrlProgress.ShowWindow(b);
890 this->m_ctrlProgLabel.ShowWindow(b);
891 this->m_ctrlAnimate.Open(IDR_DOWNLOAD);
892 if(b == SW_NORMAL)
893 this->m_ctrlAnimate.Play(0, UINT_MAX, UINT_MAX);
894 else
895 this->m_ctrlAnimate.Stop();
896 }
897 void CSyncDlg::ShowInputCtrl(bool bShow)
898 {
899 int b=bShow?SW_NORMAL:SW_HIDE;
900 this->m_ctrlURL.ShowWindow(b);
901 this->m_ctrlLocalBranch.ShowWindow(b);
902 this->m_ctrlRemoteBranch.ShowWindow(b);
903 this->GetDlgItem(IDC_BUTTON_LOCAL_BRANCH)->ShowWindow(b);
904 this->GetDlgItem(IDC_BUTTON_REMOTE_BRANCH)->ShowWindow(b);
905 this->GetDlgItem(IDC_STATIC_LOCAL_BRANCH)->ShowWindow(b);
906 this->GetDlgItem(IDC_STATIC_REMOTE_BRANCH)->ShowWindow(b);
907 this->GetDlgItem(IDC_BUTTON_MANAGE)->ShowWindow(b);
908 this->GetDlgItem(IDC_CHECK_PUTTY_KEY)->ShowWindow(b);
909 this->GetDlgItem(IDC_CHECK_FORCE)->ShowWindow(b);
910 this->GetDlgItem(IDC_STATIC_REMOTE_URL)->ShowWindow(b);
911 }
912 BOOL CSyncDlg::OnInitDialog()
913 {
914 CResizableStandAloneDialog::OnInitDialog();
915 CAppUtils::MarkWindowAsUnpinnable(m_hWnd);
916
917 // Let the TaskbarButtonCreated message through the UIPI filter. If we don't
918 // do this, Explorer would be unable to send that message to our window if we
919 // were running elevated. It's OK to make the call all the time, since if we're
920 // not elevated, this is a no-op.
921 CHANGEFILTERSTRUCT cfs = { sizeof(CHANGEFILTERSTRUCT) };
922 typedef BOOL STDAPICALLTYPE ChangeWindowMessageFilterExDFN(HWND hWnd, UINT message, DWORD action, PCHANGEFILTERSTRUCT pChangeFilterStruct);
923 CAutoLibrary hUser = AtlLoadSystemLibraryUsingFullPath(L"user32.dll");
924 if (hUser)
925 {
926 ChangeWindowMessageFilterExDFN *pfnChangeWindowMessageFilterEx = (ChangeWindowMessageFilterExDFN*)GetProcAddress(hUser, "ChangeWindowMessageFilterEx");
927 if (pfnChangeWindowMessageFilterEx)
928 {
929 pfnChangeWindowMessageFilterEx(m_hWnd, TaskBarButtonCreated, MSGFLT_ALLOW, &cfs);
930 }
931 }
932 m_pTaskbarList.Release();
933 if (FAILED(m_pTaskbarList.CoCreateInstance(CLSID_TaskbarList)))
934 m_pTaskbarList = nullptr;
935
936 this->GetDlgItem(IDC_CHECK_PUTTY_KEY)->EnableWindow(CAppUtils::IsSSHPutty());
937
938 /*
939 this->m_ctrlAnimate.ShowWindow(SW_NORMAL);
940 this->m_ctrlAnimate.Open(IDR_DOWNLOAD);
941 this->m_ctrlAnimate.Play(0,-1,-1);
942 */
943
944 // ------------------ Create Tabctrl -----------
945 CWnd *pwnd=this->GetDlgItem(IDC_BUTTON_TABCTRL);
946 CRect rectDummy;
947 pwnd->GetWindowRect(&rectDummy);
948 this->ScreenToClient(rectDummy);
949
950 if (!m_ctrlTabCtrl.Create(CMFCTabCtrl::STYLE_FLAT, rectDummy, this, IDC_SYNC_TAB))
951 {
952 TRACE0("Failed to create output tab window\n");
953 return FALSE; // fail to create
954 }
955 m_ctrlTabCtrl.SetResizeMode(CMFCTabCtrl::RESIZE_NO);
956
957 // -------------Create Command Log Ctrl ---------
958 DWORD dwStyle;
959 dwStyle= ES_MULTILINE | ES_READONLY | WS_CHILD | WS_VISIBLE | ES_AUTOHSCROLL | ES_AUTOVSCROLL |WS_VSCROLL ;
960
961 if( !m_ctrlCmdOut.Create(dwStyle,rectDummy,&m_ctrlTabCtrl,IDC_CMD_LOG))
962 {
963 TRACE0("Failed to create Log commits window\n");
964 return FALSE; // fail to create
965 }
966
967 // set the font to use in the log message view, configured in the settings dialog
968 CFont m_logFont;
969 CAppUtils::CreateFontForLogs(m_logFont);
970 m_ctrlCmdOut.SetFont(&m_logFont);
971 m_ctrlTabCtrl.InsertTab(&m_ctrlCmdOut, CString(MAKEINTRESOURCE(IDS_LOG)), -1);
972 // make the log message rich edit control send a message when the mouse pointer is over a link
973 m_ctrlCmdOut.SendMessage(EM_SETEVENTMASK, NULL, ENM_LINK | ENM_SCROLL);
974
975 //---------- Create in coming list ctrl -----------
976 dwStyle =LVS_REPORT | LVS_SHOWSELALWAYS | LVS_ALIGNLEFT | LVS_OWNERDATA | WS_BORDER | WS_TABSTOP | WS_CHILD | WS_VISIBLE;;
977
978 if( !m_InLogList.Create(dwStyle,rectDummy,&m_ctrlTabCtrl,IDC_IN_LOGLIST))
979 {
980 TRACE0("Failed to create output commits window\n");
981 return FALSE; // fail to create
982 }
983 // for some unknown reason, the SetExtendedStyle in OnCreate/PreSubclassWindow is not working here
984 m_InLogList.SetStyle();
985
986 m_ctrlTabCtrl.InsertTab(&m_InLogList, CString(MAKEINTRESOURCE(IDS_PROC_SYNC_INCOMMITS)), -1);
987
988 m_InLogList.m_ColumnRegKey = L"SyncIn";
989 m_InLogList.InsertGitColumn();
990
991 //----------- Create In Change file list -----------
992 dwStyle = LVS_REPORT | LVS_SHOWSELALWAYS | LVS_ALIGNLEFT | WS_BORDER | WS_TABSTOP | WS_CHILD | WS_VISIBLE;
993
994 if( !m_InChangeFileList.Create(dwStyle,rectDummy,&m_ctrlTabCtrl,IDC_IN_CHANGELIST))
995 {
996 TRACE0("Failed to create output change files window\n");
997 return FALSE; // fail to create
998 }
999 m_ctrlTabCtrl.InsertTab(&m_InChangeFileList, CString(MAKEINTRESOURCE(IDS_PROC_SYNC_INCHANGELIST)), -1);
1000
1001 m_InChangeFileList.Init(GITSLC_COLEXT | GITSLC_COLSTATUS |GITSLC_COLADD|GITSLC_COLDEL, L"InSyncDlg",
1002 (CGitStatusListCtrl::GetContextMenuBit(CGitStatusListCtrl::IDGITLC_COMPARETWOREVISIONS) |
1003 CGitStatusListCtrl::GetContextMenuBit(CGitStatusListCtrl::IDGITLC_GNUDIFF2REVISIONS)), false, false, GITSLC_COLEXT | GITSLC_COLSTATUS | GITSLC_COLADD | GITSLC_COLDEL);
1004
1005
1006 //---------- Create Conflict List Ctrl -----------------
1007 dwStyle = LVS_REPORT | LVS_SHOWSELALWAYS | LVS_ALIGNLEFT | WS_BORDER | WS_TABSTOP | WS_CHILD | WS_VISIBLE;
1008
1009 if( !m_ConflictFileList.Create(dwStyle,rectDummy,&m_ctrlTabCtrl,IDC_IN_CONFLICT))
1010 {
1011 TRACE0("Failed to create output change files window\n");
1012 return FALSE; // fail to create
1013 }
1014 m_ctrlTabCtrl.InsertTab(&m_ConflictFileList, CString(MAKEINTRESOURCE(IDS_PROC_SYNC_CONFLICTS)), -1);
1015
1016 m_ConflictFileList.Init(GITSLC_COLEXT | GITSLC_COLSTATUS |GITSLC_COLADD|GITSLC_COLDEL, L"ConflictSyncDlg",
1017 (GITSLC_POPEXPLORE | GITSLC_POPOPEN | GITSLC_POPSHOWLOG |
1018 GITSLC_POPCONFLICT|GITSLC_POPRESOLVE),false);
1019
1020
1021 //---------- Create Commit Out List Ctrl---------------
1022
1023 dwStyle =LVS_REPORT | LVS_SHOWSELALWAYS | LVS_ALIGNLEFT | LVS_OWNERDATA | WS_BORDER | WS_TABSTOP | WS_CHILD | WS_VISIBLE;;
1024
1025 if( !m_OutLogList.Create(dwStyle,rectDummy,&m_ctrlTabCtrl,IDC_OUT_LOGLIST))
1026 {
1027 TRACE0("Failed to create output commits window\n");
1028 return FALSE; // fail to create
1029
1030 }
1031 // for some unknown reason, the SetExtendedStyle in OnCreate/PreSubclassWindow is not working here
1032 m_OutLogList.SetStyle();
1033
1034 m_ctrlTabCtrl.InsertTab(&m_OutLogList, CString(MAKEINTRESOURCE(IDS_PROC_SYNC_OUTCOMMITS)), -1);
1035
1036 m_OutLogList.m_ColumnRegKey = L"SyncOut";
1037 m_OutLogList.InsertGitColumn();
1038
1039 //------------- Create Change File List Control ----------------
1040
1041 dwStyle = LVS_REPORT | LVS_SHOWSELALWAYS | LVS_ALIGNLEFT | WS_BORDER | WS_TABSTOP | WS_CHILD | WS_VISIBLE;
1042
1043 if( !m_OutChangeFileList.Create(dwStyle,rectDummy,&m_ctrlTabCtrl,IDC_OUT_CHANGELIST))
1044 {
1045 TRACE0("Failed to create output change files window\n");
1046 return FALSE; // fail to create
1047 }
1048 m_ctrlTabCtrl.InsertTab(&m_OutChangeFileList, CString(MAKEINTRESOURCE(IDS_PROC_SYNC_OUTCHANGELIST)), -1);
1049
1050 m_OutChangeFileList.Init(GITSLC_COLEXT | GITSLC_COLSTATUS | GITSLC_COLADD | GITSLC_COLDEL, L"OutSyncDlg",
1051 (CGitStatusListCtrl::GetContextMenuBit(CGitStatusListCtrl::IDGITLC_COMPARETWOREVISIONS) |
1052 CGitStatusListCtrl::GetContextMenuBit(CGitStatusListCtrl::IDGITLC_GNUDIFF2REVISIONS)), false, false, GITSLC_COLEXT | GITSLC_COLSTATUS | GITSLC_COLADD | GITSLC_COLDEL);
1053
1054 dwStyle = LVS_REPORT | LVS_SHOWSELALWAYS | LVS_ALIGNLEFT | WS_BORDER | WS_TABSTOP | LVS_SINGLESEL | WS_CHILD | WS_VISIBLE;
1055 if (!m_GitProgressList.Create(dwStyle | LVS_OWNERDATA, rectDummy, &m_ctrlTabCtrl, IDC_CMD_GIT_PROG))
1056 {
1057 TRACE0("Failed to create Git Progress List Window\n");
1058 return FALSE; // fail to create
1059 }
1060 m_ctrlTabCtrl.InsertTab(&m_GitProgressList, CString(MAKEINTRESOURCE(IDS_LOG)), -1);
1061 m_GitProgressList.m_pAnimate = &m_ctrlAnimate;
1062 m_GitProgressList.m_pPostWnd = this;
1063 m_GitProgressList.m_pProgressLabelCtrl = &m_ctrlProgLabel;
1064 m_GitProgressList.m_pProgControl = &m_ctrlProgress;
1065 m_GitProgressList.m_pTaskbarList = m_pTaskbarList;
1066
1067 dwStyle = LVS_REPORT | LVS_SHOWSELALWAYS | LVS_ALIGNLEFT | WS_BORDER | WS_TABSTOP | WS_CHILD | WS_VISIBLE | LVS_SINGLESEL;
1068 DWORD exStyle = LVS_EX_HEADERDRAGDROP | LVS_EX_DOUBLEBUFFER | LVS_EX_INFOTIP;
1069 if (CRegDWORD(L"Software\\TortoiseGit\\FullRowSelect", TRUE))
1070 exStyle |= LVS_EX_FULLROWSELECT;
1071 if (g_Git.m_IsUseLibGit2)
1072 {
1073 m_refList.Create(dwStyle, rectDummy, &m_ctrlTabCtrl, IDC_REFLIST);
1074 m_refList.SetExtendedStyle(exStyle);
1075 m_refList.Init();
1076 m_ctrlTabCtrl.InsertTab(&m_refList, CString(MAKEINTRESOURCE(IDS_REFLIST)), -1);
1077
1078 m_tagCompareList.Create(dwStyle, rectDummy, &m_ctrlTabCtrl, IDC_TAGCOMPARELIST);
1079 m_tagCompareList.SetExtendedStyle(exStyle);
1080 m_tagCompareList.Init();
1081 m_ctrlTabCtrl.InsertTab(&m_tagCompareList, CString(MAKEINTRESOURCE(IDS_PROC_SYNC_COMPARETAGS)), -1);
1082 }
1083
1084 AdjustControlSize(IDC_CHECK_PUTTY_KEY);
1085 AdjustControlSize(IDC_CHECK_FORCE);
1086
1087 AddAnchor(IDC_SYNC_TAB,TOP_LEFT,BOTTOM_RIGHT);
1088
1089 AddAnchor(IDC_GROUP_INFO,TOP_LEFT,TOP_RIGHT);
1090 AddAnchor(IDC_COMBOBOXEX_URL,TOP_LEFT,TOP_RIGHT);
1091 AddAnchor(IDC_BUTTON_MANAGE,TOP_RIGHT);
1092 AddAnchor(IDC_BUTTON_PULL,BOTTOM_LEFT);
1093 AddAnchor(IDC_BUTTON_PUSH,BOTTOM_LEFT);
1094 AddAnchor(IDC_BUTTON_SUBMODULE,BOTTOM_LEFT);
1095 AddAnchor(IDC_BUTTON_STASH,BOTTOM_LEFT);
1096 AddAnchor(IDC_BUTTON_APPLY,BOTTOM_RIGHT);
1097 AddAnchor(IDC_BUTTON_EMAIL,BOTTOM_RIGHT);
1098 AddAnchor(IDC_PROGRESS_SYNC,TOP_LEFT,TOP_RIGHT);
1099 AddAnchor(IDOK,BOTTOM_RIGHT);
1100 AddAnchor(IDHELP,BOTTOM_RIGHT);
1101 AddAnchor(IDC_STATIC_STATUS, BOTTOM_LEFT, BOTTOM_RIGHT);
1102 AddAnchor(IDC_ANIMATE_SYNC,TOP_LEFT);
1103 AddAnchor(IDC_BUTTON_COMMIT,BOTTOM_LEFT);
1104 AddAnchor(IDC_LOG, BOTTOM_LEFT);
1105
1106 // do not use BRANCH_COMBOX_ADD_ANCHOR here, we want to have different stylings
1107 AddAnchor(IDC_COMBOBOXEX_LOCAL_BRANCH, TOP_LEFT,TOP_CENTER);
1108 AddAnchor(IDC_COMBOBOXEX_REMOTE_BRANCH, TOP_CENTER, TOP_RIGHT);
1109 AddAnchor(IDC_BUTTON_LOCAL_BRANCH, TOP_CENTER);
1110 AddAnchor(IDC_BUTTON_REMOTE_BRANCH, TOP_RIGHT);
1111 AddAnchor(IDC_STATIC_REMOTE_BRANCH, TOP_CENTER);
1112 AddAnchor(IDC_PROG_LABEL, TOP_LEFT);
1113
1114 CString WorkingDir=g_Git.m_CurrentDir;
1115 WorkingDir.Replace(L':', L'_');
1116 m_RegKeyRemoteBranch = L"Software\\TortoiseGit\\History\\SyncBranch\\" + WorkingDir;
1117
1118
1119 this->AddOthersToAnchor();
1120
1121 this->m_ctrlPush.AddEntry(CString(MAKEINTRESOURCE(IDS_PROC_SYNC_PUSH)));
1122 this->m_ctrlPush.AddEntry(CString(MAKEINTRESOURCE(IDS_PROC_SYNC_PUSHTAGS)));
1123 this->m_ctrlPush.AddEntry(CString(MAKEINTRESOURCE(IDS_PROC_SYNC_PUSHNOTES)));
1124
1125 this->m_ctrlPull.AddEntry(CString(MAKEINTRESOURCE(IDS_PROC_SYNC_PULL)));
1126 this->m_ctrlPull.AddEntry(CString(MAKEINTRESOURCE(IDS_PROC_SYNC_FETCH)));
1127 this->m_ctrlPull.AddEntry(CString(MAKEINTRESOURCE(IDS_PROC_SYNC_FETCHREBASE)));
1128 this->m_ctrlPull.AddEntry(CString(MAKEINTRESOURCE(IDS_PROC_SYNC_FETCHALL)));
1129 this->m_ctrlPull.AddEntry(CString(MAKEINTRESOURCE(IDS_PROC_SYNC_REMOTEUPDATE)));
1130 this->m_ctrlPull.AddEntry(CString(MAKEINTRESOURCE(IDS_PROC_SYNC_CLEANUPSTALEBRANCHES)));
1131 this->m_ctrlPull.AddEntry(CString(MAKEINTRESOURCE(IDS_PROC_SYNC_COMPARETAGS)));
1132
1133 this->m_ctrlSubmodule.AddEntry(CString(MAKEINTRESOURCE(IDS_PROC_SYNC_SUBKODULEUPDATE)));
1134 this->m_ctrlSubmodule.AddEntry(CString(MAKEINTRESOURCE(IDS_PROC_SYNC_SUBKODULEINIT)));
1135 this->m_ctrlSubmodule.AddEntry(CString(MAKEINTRESOURCE(IDS_PROC_SYNC_SUBKODULESYNC)));
1136
1137 this->m_ctrlStash.AddEntry(CString(MAKEINTRESOURCE(IDS_MENUSTASHSAVE)));
1138 this->m_ctrlStash.AddEntry(CString(MAKEINTRESOURCE(IDS_MENUSTASHPOP)));
1139 this->m_ctrlStash.AddEntry(CString(MAKEINTRESOURCE(IDS_MENUSTASHAPPLY)));
1140
1141 WorkingDir.Replace(L':', L'_');
1142
1143 CString regkey ;
1144 regkey.Format(L"Software\\TortoiseGit\\TortoiseProc\\Sync\\%s", (LPCTSTR)WorkingDir);
1145
1146 this->m_regPullButton = CRegDWORD(regkey + L"\\Pull", 0);
1147 this->m_regPushButton = CRegDWORD(regkey + L"\\Push", 0);
1148 this->m_regSubmoduleButton = CRegDWORD(regkey + L"\\Submodule");
1149 this->m_regAutoLoadPutty = CRegDWORD(regkey + L"\\AutoLoadPutty", CAppUtils::IsSSHPutty());
1150
1151 this->UpdateData();
1152 this->m_bAutoLoadPuttyKey = m_regAutoLoadPutty;
1153 if(!CAppUtils::IsSSHPutty())
1154 m_bAutoLoadPuttyKey = false;
1155 this->UpdateData(FALSE);
1156
1157 this->m_ctrlPull.SetCurrentEntry(this->m_regPullButton);
1158 this->m_ctrlPush.SetCurrentEntry(this->m_regPushButton);
1159 this->m_ctrlSubmodule.SetCurrentEntry(this->m_regSubmoduleButton);
1160
1161 CString sWindowTitle;
1162 GetWindowText(sWindowTitle);
1163 CAppUtils::SetWindowTitle(m_hWnd, g_Git.m_CurrentDir, sWindowTitle);
1164
1165 EnableSaveRestore(L"SyncDlg");
1166
1167 m_ctrlURL.SetCaseSensitive(TRUE);
1168
1169 m_ctrlURL.SetCustomAutoSuggest(true, true, true);
1170 m_ctrlURL.SetMaxHistoryItems(0x7FFFFFFF);
1171 this->m_ctrlURL.LoadHistory(L"Software\\TortoiseGit\\History\\SyncURL\\" + WorkingDir, L"url");
1172
1173 m_remotelist.clear();
1174 if(!g_Git.GetRemoteList(m_remotelist))
1175 {
1176 for (unsigned int i = 0; i < m_remotelist.size(); ++i)
1177 {
1178 m_ctrlURL.AddString(m_remotelist[i]);
1179 }
1180 }
1181 m_ctrlURL.SetCurSel(0);
1182 m_ctrlRemoteBranch.SetCurSel(0);
1183
1184 this->LoadBranchInfo();
1185
1186 this->m_bInited=true;
1187 FetchOutList();
1188
1189 m_ctrlTabCtrl.ShowTab(IDC_CMD_LOG-1,false);
1190 m_ctrlTabCtrl.ShowTab(IDC_IN_LOGLIST-1,false);
1191 m_ctrlTabCtrl.ShowTab(IDC_IN_CHANGELIST-1,false);
1192 m_ctrlTabCtrl.ShowTab(IDC_IN_CONFLICT-1,false);
1193 m_ctrlTabCtrl.ShowTab(IDC_CMD_GIT_PROG-1, false);
1194 m_ctrlTabCtrl.ShowTab(IDC_REFLIST-1, false);
1195 m_ctrlTabCtrl.ShowTab(IDC_TAGCOMPARELIST - 1, false);
1196
1197 m_ctrlRemoteBranch.m_bWantReturn = TRUE;
1198 m_ctrlURL.m_bWantReturn = TRUE;
1199
1200 if (m_seq > 0 && (DWORD)CRegDWORD(L"Software\\TortoiseGit\\SyncDialogRandomPos"))
1201 {
1202 m_seq %= 5;
1203 RECT rect;
1204 GetWindowRect(&rect);
1205 rect.top -= m_seq * 30;
1206 rect.bottom -= m_seq * 30;
1207 if (rect.top < 0)
1208 {
1209 rect.top += 150;
1210 rect.bottom += 150;
1211 }
1212 MoveWindow(rect.left, rect.top, rect.right - rect.left, rect.bottom - rect.top);
1213 }
1214
1215 return TRUE; // return TRUE unless you set the focus to a control
1216 // EXCEPTION: OCX Property Pages should return FALSE
1217 }
1218
1219 void CSyncDlg::OnBnClickedButtonManage()
1220 {
1221 CAppUtils::LaunchRemoteSetting();
1222 Refresh();
1223 }
1224
1225 void CSyncDlg::Refresh()
1226 {
1227 theApp.DoWaitCursor(1);
1228
1229 int lastSelected = m_ctrlURL.GetCurSel();
1230 CString url;
1231 this->m_ctrlURL.GetWindowText(url);
1232
1233 this->m_ctrlURL.Reset();
1234 CString workingDir = g_Git.m_CurrentDir;
1235 workingDir.Replace(L':', L'_');
1236 this->m_ctrlURL.LoadHistory(L"Software\\TortoiseGit\\History\\SyncURL\\" + workingDir, L"url");
1237
1238 bool found = false;
1239 m_remotelist.clear();
1240 if (!g_Git.GetRemoteList(m_remotelist))
1241 {
1242 for (size_t i = 0; i < m_remotelist.size(); ++i)
1243 {
1244 m_ctrlURL.AddString(m_remotelist[i]);
1245 if (m_remotelist[i] == url)
1246 found = true;
1247 }
1248 }
1249 if (lastSelected >= 0 && !found)
1250 {
1251 m_ctrlURL.SetCurSel(0);
1252 m_ctrlURL.GetWindowText(url);
1253 }
1254
1255 CString local;
1256 CString remote;
1257 this->m_ctrlLocalBranch.GetWindowText(local);
1258 this->m_ctrlRemoteBranch.GetWindowText(remote);
1259
1260 this->LoadBranchInfo();
1261
1262 this->m_ctrlLocalBranch.AddString(local);
1263 this->m_ctrlRemoteBranch.AddString(remote);
1264 this->m_ctrlURL.AddString(url);
1265
1266 m_OutLogList.ShowText(CString(MAKEINTRESOURCE(IDS_PROC_SYNC_REFRESHING)));
1267 this->FetchOutList(true);
1268 theApp.DoWaitCursor(-1);
1269 }
1270
1271 BOOL CSyncDlg::PreTranslateMessage(MSG* pMsg)
1272 {
1273 if (pMsg->message == WM_KEYDOWN)
1274 {
1275 switch (pMsg->wParam)
1276 {
1277 case VK_F5:
1278 {
1279 if (m_bBlock)
1280 return CResizableStandAloneDialog::PreTranslateMessage(pMsg);
1281 Refresh();
1282 }
1283 break;
1284
1285 /* Avoid TAB control destroy but dialog exist*/
1286 case VK_ESCAPE:
1287 case VK_CANCEL:
1288 {
1289 TCHAR buff[129];
1290 ::GetClassName(pMsg->hwnd, buff, _countof(buff) - 1);
1291
1292 /* Use MSFTEDIT_CLASS http://msdn.microsoft.com/en-us/library/bb531344.aspx */
1293 if (_wcsnicmp(buff, MSFTEDIT_CLASS, _countof(buff) - 1) == 0 || //Unicode and MFC 2012 and later
1294 _wcsnicmp(buff, RICHEDIT_CLASS, _countof(buff) - 1) == 0 || //ANSI or MFC 2010
1295 _wcsnicmp(buff, L"SysListView32", _countof(buff) - 1) == 0)
1296 {
1297 this->PostMessage(WM_KEYDOWN,VK_ESCAPE,0);
1298 return TRUE;
1299 }
1300 }
1301 }
1302 }
1303 return __super::PreTranslateMessage(pMsg);
1304 }
1305 void CSyncDlg::FetchOutList(bool force)
1306 {
1307 if (!m_bInited || m_bWantToExit)
1308 return;
1309 m_OutChangeFileList.Clear();
1310 this->m_OutLogList.Clear();
1311
1312 m_ctrlTabCtrl.ShowTab(IDC_OUT_LOGLIST - 1, true);
1313 m_ctrlTabCtrl.ShowTab(IDC_OUT_CHANGELIST - 1, true);
1314
1315 CString remote;
1316 this->m_ctrlURL.GetWindowText(remote);
1317 CString remotebranch;
1318 this->m_ctrlRemoteBranch.GetWindowText(remotebranch);
1319 remotebranch = remote + L'/' + remotebranch;
1320 CGitHash remotebranchHash;
1321 g_Git.GetHash(remotebranchHash, remotebranch);
1322
1323 if(IsURL())
1324 {
1325 CString str;
1326 str.LoadString(IDS_PROC_SYNC_PUSH_UNKNOWN);
1327 m_OutLogList.ShowText(str);
1328 this->m_ctrlTabCtrl.ShowTab(m_OutChangeFileList.GetDlgCtrlID()-1,FALSE);
1329 m_OutLocalBranch.Empty();
1330 m_OutRemoteBranch.Empty();
1331
1332 this->GetDlgItem(IDC_BUTTON_EMAIL)->EnableWindow(FALSE);
1333 return ;
1334
1335 }
1336 else if(remotebranchHash.IsEmpty())
1337 {
1338 CString str;
1339 str.Format(IDS_PROC_SYNC_PUSH_UNKNOWNBRANCH, (LPCTSTR)remotebranch);
1340 m_OutLogList.ShowText(str);
1341 this->m_ctrlTabCtrl.ShowTab(m_OutChangeFileList.GetDlgCtrlID()-1,FALSE);
1342 m_OutLocalBranch.Empty();
1343 m_OutRemoteBranch.Empty();
1344
1345 this->GetDlgItem(IDC_BUTTON_EMAIL)->EnableWindow(FALSE);
1346 return ;
1347 }
1348 else
1349 {
1350 CString localbranch;
1351 localbranch=this->m_ctrlLocalBranch.GetString();
1352
1353 if(localbranch != m_OutLocalBranch || m_OutRemoteBranch != remotebranch || force)
1354 {
1355 m_OutLogList.ClearText();
1356
1357 CGitHash base, localBranchHash;
1358 bool isFastForward = g_Git.IsFastForward(remotebranch, localbranch, &base);
1359
1360 if (g_Git.GetHash(localBranchHash, localbranch))
1361 {
1362 MessageBox(g_Git.GetGitLastErr(L"Could not get hash of \"" + localbranch + L"\"."), L"TortoiseGit", MB_ICONERROR);
1363 return;
1364 }
1365 if (remotebranchHash == localBranchHash)
1366 {
1367 CString str;
1368 str.FormatMessage(IDS_PROC_SYNC_COMMITSAHEAD, 0, (LPCTSTR)remotebranch);
1369 m_OutLogList.ShowText(str);
1370 this->m_ctrlStatus.SetWindowText(str);
1371 this->m_ctrlTabCtrl.ShowTab(m_OutChangeFileList.GetDlgCtrlID()-1,FALSE);
1372 this->GetDlgItem(IDC_BUTTON_EMAIL)->EnableWindow(FALSE);
1373 }
1374 else if (isFastForward || m_bForce)
1375 {
1376 CString range;
1377 range.Format(L"%s..%s", (LPCTSTR)g_Git.FixBranchName(remotebranch), (LPCTSTR)g_Git.FixBranchName(localbranch));
1378 //fast forward
1379 m_OutLogList.FillGitLog(nullptr, &range, CGit::LOG_INFO_STAT | CGit::LOG_INFO_FILESTATE | CGit::LOG_INFO_SHOW_MERGEDFILE);
1380 CString str;
1381 str.FormatMessage(IDS_PROC_SYNC_COMMITSAHEAD, m_OutLogList.GetItemCount(), (LPCTSTR)remotebranch);
1382 this->m_ctrlStatus.SetWindowText(str);
1383
1384 if (isFastForward)
1385 AddDiffFileList(&m_OutChangeFileList, &m_arOutChangeList, localbranch, remotebranch);
1386 else
1387 {
1388 AddDiffFileList(&m_OutChangeFileList, &m_arOutChangeList, localbranch, base.ToString());
1389 }
1390
1391 this->m_ctrlTabCtrl.ShowTab(m_OutChangeFileList.GetDlgCtrlID()-1,TRUE);
1392 this->GetDlgItem(IDC_BUTTON_EMAIL)->EnableWindow(TRUE);
1393 }
1394 else
1395 {
1396 CString str;
1397 str.FormatMessage(IDS_PROC_SYNC_NOFASTFORWARD, (LPCTSTR)localbranch, (LPCTSTR)remotebranch);
1398 m_OutLogList.ShowText(str);
1399 this->m_ctrlStatus.SetWindowText(str);
1400 this->m_ctrlTabCtrl.ShowTab(m_OutChangeFileList.GetDlgCtrlID() - 1, FALSE);
1401 this->GetDlgItem(IDC_BUTTON_EMAIL)->EnableWindow(FALSE);
1402 }
1403 }
1404 this->m_OutLocalBranch=localbranch;
1405 this->m_OutRemoteBranch=remotebranch;
1406 }
1407 }
1408
1409 bool CSyncDlg::IsURL()
1410 {
1411 CString str;
1412 this->m_ctrlURL.GetWindowText(str);
1413 return str.Find(L'\\') >= 0 || str.Find(L'/') >= 0;
1414 }
1415
1416 void CSyncDlg::OnCbnEditchangeComboboxex()
1417 {
1418 SetTimer(IDT_INPUT, 1000, nullptr);
1419 this->m_OutLogList.ShowText(CString(MAKEINTRESOURCE(IDS_PROC_SYNC_WAINTINPUT)));
1420
1421 //this->FetchOutList();
1422 }
1423
1424 UINT CSyncDlg::ProgressThread()
1425 {
1426 m_startTick = GetTickCount64();
1427 m_bDone = false;
1428 STRING_VECTOR list;
1429 CProgressDlg::RunCmdList(this, m_GitCmdList, list, true, nullptr, &this->m_bAbort, &this->m_Databuf);
1430 InterlockedExchange(&m_bBlock, FALSE);
1431 return 0;
1432 }
1433
1434 LRESULT CSyncDlg::OnProgressUpdateUI(WPARAM wParam,LPARAM lParam)
1435 {
1436 if (m_bWantToExit)
1437 return 0;
1438 if(wParam == MSG_PROGRESSDLG_START)
1439 {
1440 m_BufStart = 0;
1441 m_ctrlAnimate.Play(0, UINT_MAX, UINT_MAX);
1442 this->m_ctrlProgress.SetPos(0);
1443 if (m_pTaskbarList)
1444 {
1445 m_pTaskbarList->SetProgressState(m_hWnd, TBPF_NORMAL);
1446 m_pTaskbarList->SetProgressValue(m_hWnd, 0, 100);
1447 }
1448 }
1449
1450 if(wParam == MSG_PROGRESSDLG_END || wParam == MSG_PROGRESSDLG_FAILED)
1451 {
1452 ULONGLONG tickSpent = GetTickCount64() - m_startTick;
1453 CString strEndTime = CLoglistUtils::FormatDateAndTime(CTime::GetCurrentTime(), DATE_SHORTDATE, true, false);
1454
1455 m_BufStart = 0;
1456 m_Databuf.m_critSec.Lock();
1457 m_Databuf.clear();
1458 m_Databuf.m_critSec.Unlock();
1459
1460 m_bDone = true;
1461 m_ctrlAnimate.Stop();
1462 m_ctrlProgress.SetPos(100);
1463 //this->DialogEnableWindow(IDOK,TRUE);
1464
1465 {
1466 CString text;
1467 m_ctrlCmdOut.GetWindowText(text);
1468 text.Remove('\r');
1469 CAppUtils::StyleURLs(text, &m_ctrlCmdOut);
1470 }
1471
1472 DWORD exitCode = (DWORD)lParam;
1473 if (exitCode)
1474 {
1475 if (m_pTaskbarList)
1476 {
1477 m_pTaskbarList->SetProgressState(m_hWnd, TBPF_ERROR);
1478 m_pTaskbarList->SetProgressValue(m_hWnd, 100, 100);
1479 }
1480 CString log;
1481 log.Format(IDS_PROC_PROGRESS_GITUNCLEANEXIT, exitCode);
1482 CString err;
1483 err.Format(L"\r\n\r\n%s (%I64u ms @ %s)\r\n", (LPCTSTR)log, tickSpent, (LPCTSTR)strEndTime);
1484 CProgressDlg::InsertColorText(this->m_ctrlCmdOut, err, RGB(255,0,0));
1485 if (CRegDWORD(L"Software\\TortoiseGit\\NoSounds", FALSE) == FALSE)
1486 PlaySound((LPCTSTR)SND_ALIAS_SYSTEMEXCLAMATION, nullptr, SND_ALIAS_ID | SND_ASYNC);
1487 }
1488 else
1489 {
1490 if (m_pTaskbarList)
1491 m_pTaskbarList->SetProgressState(m_hWnd, TBPF_NOPROGRESS);
1492 CString temp;
1493 temp.LoadString(IDS_SUCCESS);
1494 CString log;
1495 log.Format(L"\r\n%s (%I64u ms @ %s)\r\n", (LPCTSTR)temp, tickSpent, (LPCTSTR)strEndTime);
1496 CProgressDlg::InsertColorText(this->m_ctrlCmdOut, log, RGB(0,0,255));
1497 }
1498 m_GitCmdStatus = exitCode;
1499
1500 //if(wParam == MSG_PROGRESSDLG_END)
1501 RunPostAction();
1502 }
1503
1504 if(lParam != 0)
1505 ParserCmdOutput((char)lParam);
1506 else
1507 {
1508 m_Databuf.m_critSec.Lock();
1509 for (size_t i = m_BufStart; i < m_Databuf.size(); ++i)
1510 {
1511 char c = m_Databuf[m_BufStart];
1512 ++m_BufStart;
1513 m_Databuf.m_critSec.Unlock();
1514 ParserCmdOutput(c);
1515
1516 m_Databuf.m_critSec.Lock();
1517 }
1518
1519 if (m_BufStart > 1000)
1520 {
1521 m_Databuf.erase(m_Databuf.cbegin(), m_Databuf.cbegin() + m_BufStart);
1522 m_BufStart = 0;
1523 }
1524 m_Databuf.m_critSec.Unlock();
1525 }
1526
1527 return 0;
1528 }
1529
1530 static REF_VECTOR HashMapToRefMap(MAP_HASH_NAME& map)
1531 {
1532 auto rmap = REF_VECTOR();
1533 for (auto mit = map.cbegin(); mit != map.cend(); ++mit)
1534 {
1535 for (auto rit = mit->second.cbegin(); rit != mit->second.cend(); ++rit)
1536 {
1537 rmap.emplace_back(TGitRef{ *rit, mit->first });
1538 }
1539 }
1540 return rmap;
1541 }
1542
1543 void CSyncDlg::FillNewRefMap()
1544 {
1545 m_refList.Clear();
1546 m_newHashMap.clear();
1547
1548 if (!g_Git.m_IsUseLibGit2)
1549 return;
1550
1551 CAutoRepository repo(g_Git.GetGitRepository());
1552 if (!repo)
1553 {
1554 CMessageBox::Show(m_hWnd, CGit::GetLibGit2LastErr(L"Could not open repository."), L"TortoiseGit", MB_OK | MB_ICONERROR);
1555 return;
1556 }
1557
1558 if (CGit::GetMapHashToFriendName(repo, m_newHashMap))
1559 {
1560 MessageBox(CGit::GetLibGit2LastErr(L"Could not get all refs."), L"TortoiseGit", MB_ICONERROR);
1561 return;
1562 }
1563
1564 auto oldRefMap = HashMapToRefMap(m_oldHashMap);
1565 auto newRefMap = HashMapToRefMap(m_newHashMap);
1566 for (auto oit = oldRefMap.cbegin(); oit != oldRefMap.cend(); ++oit)
1567 {
1568 bool found = false;
1569 for (auto nit = newRefMap.cbegin(); nit != newRefMap.cend(); ++nit)
1570 {
1571 // changed ref
1572 if (oit->name == nit->name)
1573 {
1574 found = true;
1575 m_refList.AddEntry(repo, oit->name, &oit->hash, &nit->hash);
1576 break;
1577 }
1578 }
1579 // deleted ref
1580 if (!found)
1581 m_refList.AddEntry(repo, oit->name, &oit->hash, nullptr);
1582 }
1583 for (auto nit = newRefMap.cbegin(); nit != newRefMap.cend(); ++nit)
1584 {
1585 bool found = false;
1586 for (auto oit = oldRefMap.cbegin(); oit != oldRefMap.cend(); ++oit)
1587 {
1588 if (oit->name == nit->name)
1589 {
1590 found = true;
1591 break;
1592 }
1593 }
1594 // new ref
1595 if (!found)
1596 m_refList.AddEntry(repo, nit->name, nullptr, &nit->hash);
1597 }
1598 m_refList.Show();
1599 }
1600
1601 void CSyncDlg::RunPostAction()
1602 {
1603 if (m_bWantToExit)
1604 return;
1605
1606 FillNewRefMap();
1607
1608 if (this->m_CurrentCmd == GIT_COMMAND_PUSH)
1609 {
1610 DWORD exitcode = 0xFFFFFFFF;
1611 CString error;
1612 if (CHooks::Instance().PostPush(g_Git.m_CurrentDir, exitcode, error))
1613 {
1614 if (exitcode)
1615 {
1616 CString temp;
1617 temp.Format(IDS_ERR_HOOKFAILED, (LPCTSTR)error);
1618 CMessageBox::Show(GetSafeHwnd(), temp, L"TortoiseGit", MB_OK | MB_ICONERROR);
1619 return;
1620 }
1621 }
1622
1623 EnableControlButton(true);
1624 SwitchToInput();
1625 this->FetchOutList(true);
1626 }
1627 else if (this->m_CurrentCmd == GIT_COMMAND_PULL)
1628 PullComplete();
1629 else if (this->m_CurrentCmd == GIT_COMMAND_FETCH || this->m_CurrentCmd == GIT_COMMAND_FETCHANDREBASE)
1630 FetchComplete();
1631 else if (this->m_CurrentCmd == GIT_COMMAND_SUBMODULE)
1632 {
1633 //this->m_ctrlCmdOut.SetSel(-1,-1);
1634 //this->m_ctrlCmdOut.ReplaceSel(L"Done\r\n");
1635 //this->m_ctrlCmdOut.SetSel(-1,-1);
1636 EnableControlButton(true);
1637 SwitchToInput();
1638 }
1639 else if (this->m_CurrentCmd == GIT_COMMAND_STASH)
1640 StashComplete();
1641 else if (this->m_CurrentCmd == GIT_COMMAND_REMOTE)
1642 {
1643 this->FetchOutList(true);
1644 EnableControlButton(true);
1645 SwitchToInput();
1646 ShowTab(IDC_REFLIST);
1647 }
1648 }
1649 void CSyncDlg::ParserCmdOutput(char ch)
1650 {
1651 if (m_bAbort)
1652 return;
1653 CProgressDlg::ParserCmdOutput(m_ctrlCmdOut,m_ctrlProgress,m_hWnd,m_pTaskbarList,m_LogText,ch);
1654 }
1655 void CSyncDlg::OnBnClickedButtonCommit()
1656 {
1657 CString cmd = L"/command:commit";
1658 cmd += L" /path:\"";
1659 cmd += g_Git.m_CurrentDir;
1660 cmd += L'"';
1661
1662 CAppUtils::RunTortoiseGitProc(cmd);
1663 }
1664
1665 void CSyncDlg::OnOK()
1666 {
1667 UpdateCombox();
1668 this->UpdateData();
1669 m_ctrlURL.SaveHistory();
1670 SaveHistory();
1671 m_regAutoLoadPutty = this->m_bAutoLoadPuttyKey;
1672 m_tooltips.Pop();
1673 __super::OnOK();
1674 }
1675
1676 void CSyncDlg::OnCancel()
1677 {
1678 m_bAbort = true;
1679 m_GitProgressList.Cancel();
1680 if (m_bDone && !m_GitProgressList.IsRunning())
1681 {
1682 CResizableStandAloneDialog::OnCancel();
1683 return;
1684 }
1685 if (m_GitProgressList.IsRunning())
1686 WaitForSingleObject(m_GitProgressList.m_pThread->m_hThread, 10000);
1687
1688 if (g_Git.m_CurrentGitPi.hProcess)
1689 {
1690 DWORD dwConfirmKillProcess = CRegDWORD(L"Software\\TortoiseGit\\ConfirmKillProcess");
1691 if (dwConfirmKillProcess && CMessageBox::Show(m_hWnd, IDS_PROC_CONFIRMKILLPROCESS, IDS_APPNAME, MB_YESNO | MB_ICONQUESTION) != IDYES)
1692 return;
1693 if (::GenerateConsoleCtrlEvent(CTRL_C_EVENT, 0))
1694 ::WaitForSingleObject(g_Git.m_CurrentGitPi.hProcess, 10000);
1695
1696 CProgressDlg::KillProcessTree(g_Git.m_CurrentGitPi.dwProcessId);
1697 }
1698
1699 ::WaitForSingleObject(g_Git.m_CurrentGitPi.hProcess ,10000);
1700 if (m_pThread)
1701 {
1702 if (::WaitForSingleObject(m_pThread->m_hThread, 5000) == WAIT_TIMEOUT)
1703 g_Git.KillRelatedThreads(m_pThread);
1704 }
1705 m_tooltips.Pop();
1706 CResizableStandAloneDialog::OnCancel();
1707 }
1708
1709 void CSyncDlg::OnBnClickedButtonSubmodule()
1710 {
1711 bool bShift = (GetAsyncKeyState(VK_SHIFT) & 0x8000) != 0;
1712 this->UpdateData();
1713 UpdateCombox();
1714
1715 if (bShift)
1716 {
1717 switch (m_ctrlSubmodule.GetCurrentEntry())
1718 {
1719 case 0:
1720 case 1: // fall-through
1721 CAppUtils::RunTortoiseGitProc(L"/command:subupdate /bkpath:\"" + g_Git.m_CurrentDir + L"\"");
1722 break;
1723 case 2:
1724 CAppUtils::RunTortoiseGitProc(L"/command:subsync /bkpath:\"" + g_Git.m_CurrentDir + L"\"");
1725 break;
1726 }
1727 return;
1728 }
1729
1730 m_ctrlCmdOut.SetWindowText(L"");
1731 m_LogText.Empty();
1732
1733 this->m_regSubmoduleButton = (DWORD)this->m_ctrlSubmodule.GetCurrentEntry();
1734
1735 this->SwitchToRun();
1736
1737 this->m_bAbort=false;
1738 this->m_GitCmdList.clear();
1739
1740 ShowTab(IDC_CMD_LOG);
1741
1742 CString cmd;
1743
1744 switch (m_ctrlSubmodule.GetCurrentEntry())
1745 {
1746 case 0:
1747 cmd = L"git.exe submodule update --init";
1748 break;
1749 case 1:
1750 cmd = L"git.exe submodule init";
1751 break;
1752 case 2:
1753 cmd = L"git.exe submodule sync";
1754 break;
1755 }
1756
1757 m_GitCmdList.push_back(cmd);
1758
1759 m_CurrentCmd = GIT_COMMAND_SUBMODULE;
1760
1761 m_pThread = AfxBeginThread(ProgressThreadEntry, this, THREAD_PRIORITY_NORMAL,0,CREATE_SUSPENDED);
1762 if (!m_pThread)
1763 {
1764 // ReportError(CString(MAKEINTRESOURCE(IDS_ERR_THREADSTARTFAILED)));
1765 }
1766 else
1767 {
1768 m_pThread->m_bAutoDelete = TRUE;
1769 m_pThread->ResumeThread();
1770 }
1771 }
1772
1773 void CSyncDlg::OnBnClickedButtonStash()
1774 {
1775 bool bShift = (GetAsyncKeyState(VK_SHIFT) & 0x8000) != 0;
1776 UpdateData();
1777 UpdateCombox();
1778
1779 if (bShift)
1780 {
1781 if (m_ctrlStash.GetCurrentEntry() == 0)
1782 CAppUtils::RunTortoiseGitProc(L"/command:stashsave");
1783 return;
1784 }
1785
1786 m_ctrlCmdOut.SetWindowText(L"");
1787 m_LogText.Empty();
1788
1789 SwitchToRun();
1790
1791 m_bAbort = false;
1792 m_GitCmdList.clear();
1793
1794 ShowTab(IDC_CMD_LOG);
1795
1796 m_ctrlTabCtrl.ShowTab(IDC_IN_LOGLIST - 1, false);
1797 m_ctrlTabCtrl.ShowTab(IDC_IN_CHANGELIST -1, false);
1798 m_ctrlTabCtrl.ShowTab(IDC_IN_CONFLICT -1, false);
1799
1800 CString cmd;
1801 switch (m_ctrlStash.GetCurrentEntry())
1802 {
1803 case 0:
1804 cmd = L"git.exe stash push";
1805 if (!CAppUtils::IsGitVersionNewerOrEqual(GetSafeHwnd(), 2, 14))
1806 cmd = L"git.exe stash save";
1807 break;
1808 case 1:
1809 cmd = L"git.exe stash pop";
1810 break;
1811 case 2:
1812 cmd = L"git.exe stash apply";
1813 break;
1814 }
1815
1816 m_GitCmdList.push_back(cmd);
1817 m_CurrentCmd = GIT_COMMAND_STASH;
1818
1819 m_pThread = AfxBeginThread(ProgressThreadEntry, this, THREAD_PRIORITY_NORMAL, 0, CREATE_SUSPENDED);
1820 if (!m_pThread)
1821 {
1822 //ReportError(CString(MAKEINTRESOURCE(IDS_ERR_THREADSTARTFAILED)));
1823 }
1824 else
1825 {
1826 m_pThread->m_bAutoDelete = TRUE;
1827 m_pThread->ResumeThread();
1828 }
1829 }
1830
1831 void CSyncDlg::OnTimer(UINT_PTR nIDEvent)
1832 {
1833 if( nIDEvent == IDT_INPUT)
1834 {
1835 KillTimer(IDT_INPUT);
1836 this->FetchOutList(true);
1837 m_ctrlTabCtrl.ShowTab(IDC_TAGCOMPARELIST - 1, false);
1838 }
1839 }
1840
1841 LRESULT CSyncDlg::OnTaskbarBtnCreated(WPARAM wParam, LPARAM lParam)
1842 {
1843 m_pTaskbarList.Release();
1844 m_pTaskbarList.CoCreateInstance(CLSID_TaskbarList);
1845 m_GitProgressList.m_pTaskbarList = m_pTaskbarList;
1846 return __super::OnTaskbarButtonCreated(wParam, lParam);
1847 }
1848
1849 void CSyncDlg::OnBnClickedCheckForce()
1850 {
1851 UpdateData();
1852 }
1853
1854 void CSyncDlg::OnBnClickedLog()
1855 {
1856 CString cmd = L"/command:log";
1857 cmd += L" /path:\"";
1858 cmd += g_Git.m_CurrentDir;
1859 cmd += L'"';
1860
1861 CAppUtils::RunTortoiseGitProc(cmd);
1862 }
1863
1864 LRESULT CSyncDlg::OnProgCmdFinish(WPARAM /*wParam*/, LPARAM /*lParam*/)
1865 {
1866 RefreshCursor();
1867 RunPostAction();
1868 return 0;
1869 }
1870
1871 void CSyncDlg::OnDestroy()
1872 {
1873 m_bWantToExit = true;
1874 __super::OnDestroy();
1875 }
1876
1877 LRESULT CSyncDlg::OnThemeChanged()
1878 {
1879 CMFCVisualManager::GetInstance()->DestroyInstance();
1880 return 0;
1881 }
1882
1883 void CSyncDlg::OnEnLinkLog(NMHDR *pNMHDR, LRESULT *pResult)
1884 {
1885 // similar code in ProgressDlg.cpp and LogDlg.cpp
1886 ENLINK *pEnLink = reinterpret_cast<ENLINK *>(pNMHDR);
1887 if ((pEnLink->msg == WM_LBUTTONUP) || (pEnLink->msg == WM_SETCURSOR))
1888 {
1889 CString msg;
1890 m_ctrlCmdOut.GetWindowText(msg);
1891 msg.Replace(L"\r\n", L"\n");
1892 CString url = msg.Mid(pEnLink->chrg.cpMin, pEnLink->chrg.cpMax - pEnLink->chrg.cpMin);
1893 // check if it's an email address
1894 auto atpos = url.Find(L'@');
1895 if ((atpos > 0) && (url.ReverseFind(L'.') > atpos) && !::PathIsURL(url))
1896 url = L"mailto:" + url;
1897 if (::PathIsURL(url))
1898 {
1899 if (pEnLink->msg == WM_LBUTTONUP)
1900 ShellExecute(GetSafeHwnd(), L"open", url, nullptr, nullptr, SW_SHOWDEFAULT);
1901 else
1902 {
1903 static RECT prevRect = { 0 };
1904 CWnd* pMsgView = &m_ctrlCmdOut;
1905 if (pMsgView)
1906 {
1907 RECT rc;
1908 POINTL pt;
1909 pMsgView->SendMessage(EM_POSFROMCHAR, (WPARAM)&pt, pEnLink->chrg.cpMin);
1910 rc.left = pt.x;
1911 rc.top = pt.y;
1912 pMsgView->SendMessage(EM_POSFROMCHAR, (WPARAM)&pt, pEnLink->chrg.cpMax);
1913 rc.right = pt.x;
1914 rc.bottom = pt.y + 12;
1915 if ((prevRect.left != rc.left) || (prevRect.top != rc.top))
1916 {
1917 m_tooltips.DelTool(pMsgView, 1);
1918 m_tooltips.AddTool(pMsgView, url, &rc, 1);
1919 prevRect = rc;
1920 }
1921 }
1922 }
1923 }
1924 }
1925 *pResult = 0;
1926 }
1927
1928 void CSyncDlg::OnEnscrollLog()
1929 {
1930 m_tooltips.DelTool(&m_ctrlCmdOut, 1);
1931 }
Windows Explorer Extension to Operate Git