src/TortoiseProc/SyncDlg.cpp

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