src/TortoiseProc/SyncDlg.cpp

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