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