src/TortoiseProc/SyncDlg.cpp

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