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