src/TortoiseProc/SyncDlg.cpp

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