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