src/TortoiseProc/SyncDlg.cpp

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