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         this->m_ctrlURL.LoadHistory(CString(_T("Software\\TortoiseGit\\History\\SyncURL\\"))+WorkingDir, _T("url"));
 929
 930         STRING_VECTOR list;
 931
 932         if(!g_Git.GetRemoteList(list))
 933         {
 934                 for (unsigned int i = 0; i < list.size(); ++i)
 935                 {
 936                         m_ctrlURL.AddString(list[i]);
 937                 }
 938         }
 939         m_ctrlURL.SetCurSel(0);
 940         m_ctrlRemoteBranch.SetCurSel(0);
 941
 942         this->LoadBranchInfo();
 943
 944         this->m_bInited=true;
 945         FetchOutList();
 946
 947         m_ctrlTabCtrl.ShowTab(IDC_CMD_LOG-1,false);
 948         m_ctrlTabCtrl.ShowTab(IDC_IN_LOGLIST-1,false);
 949         m_ctrlTabCtrl.ShowTab(IDC_IN_CHANGELIST-1,false);
 950         m_ctrlTabCtrl.ShowTab(IDC_IN_CONFLICT-1,false);
 951         m_ctrlTabCtrl.ShowTab(IDC_CMD_GIT_PROG-1, false);
 952         m_ctrlTabCtrl.ShowTab(IDC_REFLIST-1, false);
 953
 954         m_ctrlRemoteBranch.m_bWantReturn = TRUE;
 955         m_ctrlURL.m_bWantReturn = TRUE;
 956
 957         this->m_Gitverion = CAppUtils::GetMsysgitVersion();
 958
 959         if (m_seq > 0 && (DWORD)CRegDWORD(_T("Software\\TortoiseGit\\SyncDialogRandomPos")))
 960         {
 961                 m_seq %= 5;
 962                 RECT rect;
 963                 GetWindowRect(&rect);
 964                 rect.top -= m_seq * 30;
 965                 rect.bottom -= m_seq * 30;
 966                 if (rect.top < 0)
 967                 {
 968                         rect.top += 150;
 969                         rect.bottom += 150;
 970                 }
 971                 MoveWindow(rect.left, rect.top, rect.right - rect.left, rect.bottom - rect.top);
 972         }
 973
 974         return TRUE;  // return TRUE unless you set the focus to a control
 975         // EXCEPTION: OCX Property Pages should return FALSE
 976 }
 977
 978 void CSyncDlg::OnBnClickedButtonManage()
 979 {
 980         CAppUtils::LaunchRemoteSetting();
 981         Refresh();
 982 }
 983
 984 void CSyncDlg::Refresh()
 985 {
 986         theApp.DoWaitCursor(1);
 987
 988         int lastSelected = m_ctrlURL.GetCurSel();
 989         CString url;
 990         this->m_ctrlURL.GetWindowText(url);
 991
 992         this->m_ctrlURL.Reset();
 993         CString workingDir = g_Git.m_CurrentDir;
 994         workingDir.Replace(_T(':'), _T('_'));
 995         this->m_ctrlURL.LoadHistory(_T("Software\\TortoiseGit\\History\\SyncURL\\") + workingDir, _T("url"));
 996
 997         STRING_VECTOR list;
 998         bool found = false;
 999         if (!g_Git.GetRemoteList(list))
1000         {
1001                 for (size_t i = 0; i < list.size(); ++i)
1002                 {
1003                         m_ctrlURL.AddString(list[i]);
1004                         if (list[i] == url)
1005                                 found = true;
1006                 }
1007         }
1008         if (lastSelected >= 0 && !found)
1009         {
1010                 m_ctrlURL.SetCurSel(0);
1011                 m_ctrlURL.GetWindowText(url);
1012         }
1013
1014         CString local;
1015         CString remote;
1016         this->m_ctrlLocalBranch.GetWindowText(local);
1017         this->m_ctrlRemoteBranch.GetWindowText(remote);
1018
1019         this->LoadBranchInfo();
1020
1021         this->m_ctrlLocalBranch.AddString(local);
1022         this->m_ctrlRemoteBranch.AddString(remote);
1023         this->m_ctrlURL.AddString(url);
1024
1025         m_OutLogList.ShowText(CString(MAKEINTRESOURCE(IDS_PROC_SYNC_REFRESHING)));
1026         this->FetchOutList(true);
1027         theApp.DoWaitCursor(-1);
1028 }
1029
1030 BOOL CSyncDlg::PreTranslateMessage(MSG* pMsg)
1031 {
1032         if (pMsg->message == WM_KEYDOWN)
1033         {
1034                 switch (pMsg->wParam)
1035                 {
1036
1037                 case VK_F5:
1038                         {
1039                                 if (m_bBlock)
1040                                         return CResizableStandAloneDialog::PreTranslateMessage(pMsg);
1041                                 Refresh();
1042                         }
1043                 break;
1044
1045                 /* Avoid TAB control destroy but dialog exist*/
1046                 case VK_ESCAPE:
1047                 case VK_CANCEL:
1048                         {
1049                                 TCHAR buff[128] = { 0 };
1050                                 ::GetClassName(pMsg->hwnd,buff,128);
1051
1052                                 /* Use MSFTEDIT_CLASS http://msdn.microsoft.com/en-us/library/bb531344.aspx */
1053                                 if (_tcsnicmp(buff, MSFTEDIT_CLASS, 128) == 0 ||        //Unicode and MFC 2012 and later
1054                                         _tcsnicmp(buff, RICHEDIT_CLASS, 128) == 0 ||    //ANSI or MFC 2010
1055                                         _tcsnicmp(buff, _T("SysListView32"), 128) == 0)
1056                                 {
1057                                         this->PostMessage(WM_KEYDOWN,VK_ESCAPE,0);
1058                                         return TRUE;
1059                                 }
1060                         }
1061                 }
1062         }
1063         return __super::PreTranslateMessage(pMsg);
1064 }
1065 void CSyncDlg::FetchOutList(bool force)
1066 {
1067         if(!m_bInited)
1068                 return;
1069         m_OutChangeFileList.Clear();
1070         this->m_OutLogList.Clear();
1071
1072         CString remote;
1073         this->m_ctrlURL.GetWindowText(remote);
1074         CString remotebranch;
1075         this->m_ctrlRemoteBranch.GetWindowText(remotebranch);
1076         remotebranch=remote+_T("/")+remotebranch;
1077         CGitHash remotebranchHash;
1078         g_Git.GetHash(remotebranchHash, remotebranch);
1079
1080         if(IsURL())
1081         {
1082                 CString str;
1083                 str.LoadString(IDS_PROC_SYNC_PUSH_UNKNOWN);
1084                 m_OutLogList.ShowText(str);
1085                 this->m_ctrlTabCtrl.ShowTab(m_OutChangeFileList.GetDlgCtrlID()-1,FALSE);
1086                 m_OutLocalBranch.Empty();
1087                 m_OutRemoteBranch.Empty();
1088
1089                 this->GetDlgItem(IDC_BUTTON_EMAIL)->EnableWindow(FALSE);
1090                 return ;
1091
1092         }
1093         else if(remotebranchHash.IsEmpty())
1094         {
1095                 CString str;
1096                 str.Format(IDS_PROC_SYNC_PUSH_UNKNOWNBRANCH, remotebranch);
1097                 m_OutLogList.ShowText(str);
1098                 this->m_ctrlTabCtrl.ShowTab(m_OutChangeFileList.GetDlgCtrlID()-1,FALSE);
1099                 m_OutLocalBranch.Empty();
1100                 m_OutRemoteBranch.Empty();
1101
1102                 this->GetDlgItem(IDC_BUTTON_EMAIL)->EnableWindow(FALSE);
1103                 return ;
1104         }
1105         else
1106         {
1107                 CString localbranch;
1108                 localbranch=this->m_ctrlLocalBranch.GetString();
1109
1110                 if(localbranch != m_OutLocalBranch || m_OutRemoteBranch != remotebranch || force)
1111                 {
1112                         m_OutLogList.ClearText();
1113
1114                         CGitHash base, localBranchHash;
1115                         bool isFastForward = g_Git.IsFastForward(remotebranch, localbranch, &base);
1116
1117                         if (g_Git.GetHash(localBranchHash, localbranch))
1118                         {
1119                                 MessageBox(g_Git.GetGitLastErr(_T("Could not get hash of \"") + localbranch + _T("\".")), _T("TortoiseGit"), MB_ICONERROR);
1120                                 return;
1121                         }
1122                         if (remotebranchHash == localBranchHash)
1123                         {
1124                                 CString str;
1125                                 str.Format(IDS_PROC_SYNC_COMMITSAHEAD, 0, remotebranch);
1126                                 m_OutLogList.ShowText(str);
1127                                 this->m_ctrlStatus.SetWindowText(str);
1128                                 this->m_ctrlTabCtrl.ShowTab(m_OutChangeFileList.GetDlgCtrlID()-1,FALSE);
1129                                 this->GetDlgItem(IDC_BUTTON_EMAIL)->EnableWindow(FALSE);
1130                         }
1131                         else if (isFastForward || m_bForce)
1132                         {
1133                                 CString range;
1134                                 range.Format(_T("%s..%s"), g_Git.FixBranchName(remotebranch), g_Git.FixBranchName(localbranch));
1135                                 //fast forward
1136                                 m_OutLogList.FillGitLog(nullptr, &range, CGit::LOG_INFO_STAT | CGit::LOG_INFO_FILESTATE | CGit::LOG_INFO_SHOW_MERGEDFILE);
1137                                 CString str;
1138                                 str.Format(IDS_PROC_SYNC_COMMITSAHEAD, m_OutLogList.GetItemCount(), remotebranch);
1139                                 this->m_ctrlStatus.SetWindowText(str);
1140
1141                                 if (isFastForward)
1142                                         AddDiffFileList(&m_OutChangeFileList, &m_arOutChangeList, localbranch, remotebranch);
1143                                 else
1144                                 {
1145                                         AddDiffFileList(&m_OutChangeFileList, &m_arOutChangeList, localbranch, base.ToString());
1146                                 }
1147
1148                                 this->m_ctrlTabCtrl.ShowTab(m_OutChangeFileList.GetDlgCtrlID()-1,TRUE);
1149                                 this->GetDlgItem(IDC_BUTTON_EMAIL)->EnableWindow(TRUE);
1150                         }
1151                         else
1152                         {
1153                                 CString str;
1154                                 str.Format(IDS_PROC_SYNC_NOFASTFORWARD, localbranch, remotebranch);
1155                                 m_OutLogList.ShowText(str);
1156                                 this->m_ctrlStatus.SetWindowText(str);
1157                                 this->m_ctrlTabCtrl.ShowTab(m_OutChangeFileList.GetDlgCtrlID() - 1, FALSE);
1158                                 this->GetDlgItem(IDC_BUTTON_EMAIL)->EnableWindow(FALSE);
1159                         }
1160                 }
1161                 this->m_OutLocalBranch=localbranch;
1162                 this->m_OutRemoteBranch=remotebranch;
1163         }
1164
1165 }
1166
1167 bool CSyncDlg::IsURL()
1168 {
1169         CString str;
1170         this->m_ctrlURL.GetWindowText(str);
1171         if(str.Find(_T('\\'))>=0 || str.Find(_T('/'))>=0)
1172                 return true;
1173         else
1174                 return false;
1175 }
1176 void CSyncDlg::OnCbnEditchangeComboboxex()
1177 {
1178         SetTimer(IDT_INPUT, 1000, NULL);
1179         this->m_OutLogList.ShowText(CString(MAKEINTRESOURCE(IDS_PROC_SYNC_WAINTINPUT)));
1180
1181         //this->FetchOutList();
1182 }
1183
1184 UINT CSyncDlg::ProgressThread()
1185 {
1186         m_startTick = GetTickCount();
1187         m_bDone = false;
1188         STRING_VECTOR list;
1189         CProgressDlg::RunCmdList(this, m_GitCmdList, list, true, nullptr, &this->m_bAbort, &this->m_Databuf);
1190         InterlockedExchange(&m_bBlock, FALSE);
1191         return 0;
1192 }
1193
1194
1195 LRESULT CSyncDlg::OnProgressUpdateUI(WPARAM wParam,LPARAM lParam)
1196 {
1197         if(wParam == MSG_PROGRESSDLG_START)
1198         {
1199                 m_BufStart = 0;
1200                 m_ctrlAnimate.Play(0, UINT_MAX, UINT_MAX);
1201                 this->m_ctrlProgress.SetPos(0);
1202                 if (m_pTaskbarList)
1203                 {
1204                         m_pTaskbarList->SetProgressState(m_hWnd, TBPF_NORMAL);
1205                         m_pTaskbarList->SetProgressValue(m_hWnd, 0, 100);
1206                 }
1207         }
1208
1209         if(wParam == MSG_PROGRESSDLG_END || wParam == MSG_PROGRESSDLG_FAILED)
1210         {
1211                 DWORD tickSpent = GetTickCount() - m_startTick;
1212                 CString strEndTime = CLoglistUtils::FormatDateAndTime(CTime::GetCurrentTime(), DATE_SHORTDATE, true, false);
1213
1214                 m_BufStart = 0;
1215                 m_Databuf.m_critSec.Lock();
1216                 m_Databuf.clear();
1217                 m_Databuf.m_critSec.Unlock();
1218
1219                 m_bDone = true;
1220                 m_ctrlAnimate.Stop();
1221                 m_ctrlProgress.SetPos(100);
1222                 //this->DialogEnableWindow(IDOK,TRUE);
1223
1224                 DWORD exitCode = (DWORD)lParam;
1225                 if (exitCode)
1226                 {
1227                         if (m_pTaskbarList)
1228                         {
1229                                 m_pTaskbarList->SetProgressState(m_hWnd, TBPF_ERROR);
1230                                 m_pTaskbarList->SetProgressValue(m_hWnd, 100, 100);
1231                         }
1232                         CString log;
1233                         log.Format(IDS_PROC_PROGRESS_GITUNCLEANEXIT, exitCode);
1234                         CString err;
1235                         err.Format(_T("\r\n\r\n%s (%lu ms @ %s)\r\n"), log, tickSpent, strEndTime);
1236                         CProgressDlg::InsertColorText(this->m_ctrlCmdOut, err, RGB(255,0,0));
1237                         if (CRegDWORD(_T("Software\\TortoiseGit\\NoSounds"), FALSE) == FALSE)
1238                                 PlaySound((LPCTSTR)SND_ALIAS_SYSTEMEXCLAMATION, NULL, SND_ALIAS_ID | SND_ASYNC);
1239                 }
1240                 else
1241                 {
1242                         if (m_pTaskbarList)
1243                                 m_pTaskbarList->SetProgressState(m_hWnd, TBPF_NOPROGRESS);
1244                         CString temp;
1245                         temp.LoadString(IDS_SUCCESS);
1246                         CString log;
1247                         log.Format(_T("\r\n%s (%lu ms @ %s)\r\n"), temp, tickSpent, strEndTime);
1248                         CProgressDlg::InsertColorText(this->m_ctrlCmdOut, log, RGB(0,0,255));
1249                 }
1250                 m_GitCmdStatus = exitCode;
1251
1252                 //if(wParam == MSG_PROGRESSDLG_END)
1253                 RunPostAction();
1254         }
1255
1256         if(lParam != 0)
1257                 ParserCmdOutput((char)lParam);
1258         else
1259         {
1260                 m_Databuf.m_critSec.Lock();
1261                 for (size_t i = m_BufStart; i < m_Databuf.size(); ++i)
1262                 {
1263                         char c = m_Databuf[m_BufStart];
1264                         ++m_BufStart;
1265                         m_Databuf.m_critSec.Unlock();
1266                         ParserCmdOutput(c);
1267
1268                         m_Databuf.m_critSec.Lock();
1269                 }
1270
1271                 if (m_BufStart > 1000)
1272                 {
1273                         m_Databuf.erase(m_Databuf.begin(), m_Databuf.begin() + m_BufStart);
1274                         m_BufStart = 0;
1275                 }
1276                 m_Databuf.m_critSec.Unlock();
1277         }
1278
1279         return 0;
1280 }
1281
1282 static std::map<CString, CGitHash> * HashMapToRefMap(MAP_HASH_NAME &map)
1283 {
1284         auto rmap = new std::map<CString, CGitHash>();
1285         for (auto mit = map.begin(); mit != map.end(); ++mit)
1286         {
1287                 for (auto rit = mit->second.begin(); rit != mit->second.end(); ++rit)
1288                 {
1289                         rmap->insert(std::make_pair(*rit, mit->first));
1290                 }
1291         }
1292         return rmap;
1293 }
1294
1295 void CSyncDlg::FillNewRefMap()
1296 {
1297         m_refList.Clear();
1298         m_newHashMap.clear();
1299         CAutoRepository repo(g_Git.GetGitRepository());
1300         if (!repo)
1301         {
1302                 CMessageBox::Show(m_hWnd, CGit::GetLibGit2LastErr(_T("Could not open repository.")), _T("TortoiseGit"), MB_OK | MB_ICONERROR);
1303                 return;
1304         }
1305
1306         if (CGit::GetMapHashToFriendName(repo, m_newHashMap))
1307         {
1308                 MessageBox(CGit::GetLibGit2LastErr(_T("Could not get all refs.")), _T("TortoiseGit"), MB_ICONERROR);
1309                 return;
1310         }
1311
1312         auto oldRefMap = HashMapToRefMap(m_oldHashMap);
1313         auto newRefMap = HashMapToRefMap(m_newHashMap);
1314         for (auto oit = oldRefMap->begin(); oit != oldRefMap->end(); ++oit)
1315         {
1316                 bool found = false;
1317                 for (auto nit = newRefMap->begin(); nit != newRefMap->end(); ++nit)
1318                 {
1319                         // changed ref
1320                         if (oit->first == nit->first)
1321                         {
1322                                 found = true;
1323                                 m_refList.AddEntry(repo, oit->first, &oit->second, &nit->second);
1324                                 break;
1325                         }
1326                 }
1327                 // deleted ref
1328                 if (!found)
1329                 {
1330                         m_refList.AddEntry(repo, oit->first, &oit->second, nullptr);
1331                 }
1332         }
1333         for (auto nit = newRefMap->begin(); nit != newRefMap->end(); ++nit)
1334         {
1335                 bool found = false;
1336                 for (auto oit = oldRefMap->begin(); oit != oldRefMap->end(); ++oit)
1337                 {
1338                         if (oit->first == nit->first)
1339                         {
1340                                 found = true;
1341                                 break;
1342                         }
1343                 }
1344                 // new ref
1345                 if (!found)
1346                 {
1347                         m_refList.AddEntry(repo, nit->first, nullptr, &nit->second);
1348                 }
1349         }
1350         delete oldRefMap;
1351         delete newRefMap;
1352         m_refList.Show();
1353 }
1354
1355 void CSyncDlg::RunPostAction()
1356 {
1357         if (m_bWantToExit)
1358                 return;
1359
1360         FillNewRefMap();
1361
1362         if (this->m_CurrentCmd == GIT_COMMAND_PUSH)
1363         {
1364                 DWORD exitcode = 0xFFFFFFFF;
1365                 CString error;
1366                 if (CHooks::Instance().PostPush(g_Git.m_CurrentDir, exitcode, error))
1367                 {
1368                         if (exitcode)
1369                         {
1370                                 CString temp;
1371                                 temp.Format(IDS_ERR_HOOKFAILED, (LPCTSTR)error);
1372                                 CMessageBox::Show(nullptr, temp,_T("TortoiseGit"), MB_OK | MB_ICONERROR);
1373                                 return;
1374                         }
1375                 }
1376
1377                 EnableControlButton(true);
1378                 SwitchToInput();
1379                 this->FetchOutList(true);
1380         }
1381         else if (this->m_CurrentCmd == GIT_COMMAND_PULL)
1382         {
1383                 PullComplete();
1384         }
1385         else if (this->m_CurrentCmd == GIT_COMMAND_FETCH || this->m_CurrentCmd == GIT_COMMAND_FETCHANDREBASE)
1386         {
1387                 FetchComplete();
1388         }
1389         else if (this->m_CurrentCmd == GIT_COMMAND_SUBMODULE)
1390         {
1391                 //this->m_ctrlCmdOut.SetSel(-1,-1);
1392                 //this->m_ctrlCmdOut.ReplaceSel(_T("Done\r\n"));
1393                 //this->m_ctrlCmdOut.SetSel(-1,-1);
1394                 EnableControlButton(true);
1395                 SwitchToInput();
1396         }
1397         else if (this->m_CurrentCmd == GIT_COMMAND_STASH)
1398         {
1399                 StashComplete();
1400         }
1401         else if (this->m_CurrentCmd == GIT_COMMAND_REMOTE)
1402         {
1403                 this->FetchOutList(true);
1404                 EnableControlButton(true);
1405                 SwitchToInput();
1406                 ShowTab(IDC_REFLIST);
1407         }
1408 }
1409 void CSyncDlg::ParserCmdOutput(char ch)
1410 {
1411         CProgressDlg::ParserCmdOutput(m_ctrlCmdOut,m_ctrlProgress,m_hWnd,m_pTaskbarList,m_LogText,ch);
1412 }
1413 void CSyncDlg::OnBnClickedButtonCommit()
1414 {
1415         CString cmd = _T("/command:commit");
1416         cmd += _T(" /path:\"");
1417         cmd += g_Git.m_CurrentDir;
1418         cmd += _T("\"");
1419
1420         CAppUtils::RunTortoiseGitProc(cmd);
1421 }
1422
1423 void CSyncDlg::OnOK()
1424 {
1425         UpdateCombox();
1426         this->UpdateData();
1427         m_ctrlURL.SaveHistory();
1428         SaveHistory();
1429         m_regAutoLoadPutty = this->m_bAutoLoadPuttyKey;
1430         m_tooltips.Pop();
1431         __super::OnOK();
1432 }
1433
1434 void CSyncDlg::OnCancel()
1435 {
1436         m_bAbort = true;
1437         if (m_bDone)
1438         {
1439                 CResizableStandAloneDialog::OnCancel();
1440                 return;
1441         }
1442
1443         if (g_Git.m_CurrentGitPi.hProcess)
1444         {
1445                 DWORD dwConfirmKillProcess = CRegDWORD(_T("Software\\TortoiseGit\\ConfirmKillProcess"));
1446                 if (dwConfirmKillProcess && CMessageBox::Show(m_hWnd, IDS_PROC_CONFIRMKILLPROCESS, IDS_APPNAME, MB_YESNO | MB_ICONQUESTION) != IDYES)
1447                         return;
1448                 if (::GenerateConsoleCtrlEvent(CTRL_C_EVENT, 0))
1449                 {
1450                         ::WaitForSingleObject(g_Git.m_CurrentGitPi.hProcess, 10000);
1451                 }
1452                 else
1453                 {
1454                         GetLastError();
1455                 }
1456
1457                 CProgressDlg::KillProcessTree(g_Git.m_CurrentGitPi.dwProcessId);
1458         }
1459
1460         ::WaitForSingleObject(g_Git.m_CurrentGitPi.hProcess ,10000);
1461         m_tooltips.Pop();
1462         CResizableStandAloneDialog::OnCancel();
1463 }
1464
1465 void CSyncDlg::OnBnClickedButtonSubmodule()
1466 {
1467         this->UpdateData();
1468         UpdateCombox();
1469         m_ctrlCmdOut.SetWindowTextW(_T(""));
1470         m_LogText = "";
1471
1472         this->m_regSubmoduleButton = (DWORD)this->m_ctrlSubmodule.GetCurrentEntry();
1473
1474         this->SwitchToRun();
1475
1476         this->m_bAbort=false;
1477         this->m_GitCmdList.clear();
1478
1479         ShowTab(IDC_CMD_LOG);
1480
1481         CString cmd;
1482
1483         switch (m_ctrlSubmodule.GetCurrentEntry())
1484         {
1485         case 0:
1486                 cmd=_T("git.exe submodule update --init");
1487                 break;
1488         case 1:
1489                 cmd=_T("git.exe submodule init");
1490                 break;
1491         case 2:
1492                 cmd=_T("git.exe submodule sync");
1493                 break;
1494         }
1495
1496         m_GitCmdList.push_back(cmd);
1497
1498         m_CurrentCmd = GIT_COMMAND_SUBMODULE;
1499
1500         m_pThread = AfxBeginThread(ProgressThreadEntry, this, THREAD_PRIORITY_NORMAL,0,CREATE_SUSPENDED);
1501         if (m_pThread==NULL)
1502         {
1503 //              ReportError(CString(MAKEINTRESOURCE(IDS_ERR_THREADSTARTFAILED)));
1504         }
1505         else
1506         {
1507                 m_pThread->m_bAutoDelete = TRUE;
1508                 m_pThread->ResumeThread();
1509         }
1510 }
1511
1512 void CSyncDlg::OnBnClickedButtonStash()
1513 {
1514         UpdateData();
1515         UpdateCombox();
1516         m_ctrlCmdOut.SetWindowTextW(_T(""));
1517         m_LogText = "";
1518
1519         SwitchToRun();
1520
1521         m_bAbort = false;
1522         m_GitCmdList.clear();
1523
1524         ShowTab(IDC_CMD_LOG);
1525
1526         m_ctrlTabCtrl.ShowTab(IDC_IN_LOGLIST - 1, false);
1527         m_ctrlTabCtrl.ShowTab(IDC_IN_CHANGELIST -1, false);
1528         m_ctrlTabCtrl.ShowTab(IDC_IN_CONFLICT -1, false);
1529
1530         CString cmd;
1531         switch (m_ctrlStash.GetCurrentEntry())
1532         {
1533         case 0:
1534                 cmd = _T("git.exe stash save");
1535                 break;
1536         case 1:
1537                 cmd = _T("git.exe stash pop");
1538                 break;
1539         case 2:
1540                 cmd = _T("git.exe stash apply");
1541                 break;
1542         }
1543
1544         m_GitCmdList.push_back(cmd);
1545         m_CurrentCmd = GIT_COMMAND_STASH;
1546
1547         m_pThread = AfxBeginThread(ProgressThreadEntry, this, THREAD_PRIORITY_NORMAL, 0, CREATE_SUSPENDED);
1548         if (!m_pThread)
1549         {
1550                 //ReportError(CString(MAKEINTRESOURCE(IDS_ERR_THREADSTARTFAILED)));
1551         }
1552         else
1553         {
1554                 m_pThread->m_bAutoDelete = TRUE;
1555                 m_pThread->ResumeThread();
1556         }
1557 }
1558
1559 void CSyncDlg::OnTimer(UINT_PTR nIDEvent)
1560 {
1561         if( nIDEvent == IDT_INPUT)
1562         {
1563                 KillTimer(IDT_INPUT);
1564                 this->FetchOutList(true);
1565         }
1566 }
1567
1568
1569 void CSyncDlg::OnLvnInLogListColumnClick(NMHDR * /* pNMHDR */, LRESULT *pResult)
1570 {
1571         *pResult = 0;
1572 }
1573
1574 LRESULT CSyncDlg::OnTaskbarBtnCreated(WPARAM /*wParam*/, LPARAM /*lParam*/)
1575 {
1576         m_pTaskbarList.Release();
1577         m_pTaskbarList.CoCreateInstance(CLSID_TaskbarList);
1578         m_GitProgressList.m_pTaskbarList = m_pTaskbarList;
1579         SetUUIDOverlayIcon(m_hWnd);
1580         return 0;
1581 }
1582
1583 void CSyncDlg::OnBnClickedCheckForce()
1584 {
1585         UpdateData();
1586 }
1587
1588 void CSyncDlg::OnBnClickedLog()
1589 {
1590         CString cmd = _T("/command:log");
1591         cmd += _T(" /path:\"");
1592         cmd += g_Git.m_CurrentDir;
1593         cmd += _T("\"");
1594
1595         CAppUtils::RunTortoiseGitProc(cmd);
1596 }
1597
1598 LRESULT CSyncDlg::OnProgCmdFinish(WPARAM /*wParam*/, LPARAM /*lParam*/)
1599 {
1600         RefreshCursor();
1601         RunPostAction();
1602         return 0;
1603 }
1604
1605 void CSyncDlg::OnDestroy()
1606 {
1607         m_bWantToExit = true;
1608         __super::OnDestroy();
1609 }