src/TortoiseProc/SyncDlg.cpp

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