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