src/TortoiseProc/SyncDlg.cpp

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