src/TortoiseProc/SyncDlg.cpp

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