src/TortoiseProc/AppUtils.cpp

   1 // TortoiseGit - a Windows shell extension for easy version control
   2
   3 // Copyright (C) 2008-2013 - TortoiseGit
   4 // Copyright (C) 2003-2011 - TortoiseSVN
   5
   6 // This program is free software; you can redistribute it and/or
   7 // modify it under the terms of the GNU General Public License
   8 // as published by the Free Software Foundation; either version 2
   9 // of the License, or (at your option) any later version.
  10
  11 // This program is distributed in the hope that it will be useful,
  12 // but WITHOUT ANY WARRANTY; without even the implied warranty of
  13 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14 // GNU General Public License for more details.
  15
  16 // You should have received a copy of the GNU General Public License
  17 // along with this program; if not, write to the Free Software Foundation,
  18 // 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
  19 //
  20 #include "stdafx.h"
  21 #include "resource.h"
  22 #include "TortoiseProc.h"
  23 #include "PathUtils.h"
  24 #include "AppUtils.h"
  25 //#include "GitProperties.h"
  26 #include "StringUtils.h"
  27 #include "MessageBox.h"
  28 #include "registry.h"
  29 #include "TGitPath.h"
  30 #include "Git.h"
  31 //#include "RepositoryBrowser.h"
  32 //#include "BrowseFolder.h"
  33 #include "UnicodeUtils.h"
  34 #include "ExportDlg.h"
  35 #include "ProgressDlg.h"
  36 #include "GitAdminDir.h"
  37 #include "ProgressDlg.h"
  38 #include "BrowseFolder.h"
  39 #include "DirFileEnum.h"
  40 #include "MessageBox.h"
  41 #include "GitStatus.h"
  42 #include "CreateBranchTagDlg.h"
  43 #include "GitSwitchDlg.h"
  44 #include "ResetDlg.h"
  45 #include "DeleteConflictDlg.h"
  46 #include "ChangedDlg.h"
  47 #include "SendMailDlg.h"
  48 #include "GITProgressDlg.h"
  49 #include "PushDlg.h"
  50 #include "CommitDlg.h"
  51 #include "MergeDlg.h"
  52 #include "hooks.h"
  53 #include "..\Settings\Settings.h"
  54 #include "InputDlg.h"
  55 #include "SVNDCommitDlg.h"
  56 #include "requestpulldlg.h"
  57 #include "PullFetchDlg.h"
  58 #include "RebaseDlg.h"
  59 #include "PropKey.h"
  60 #include "StashSave.h"
  61 #include "IgnoreDlg.h"
  62 #include "FormatMessageWrapper.h"
  63 #include "SmartHandle.h"
  64 #include "BisectStartDlg.h"
  65 #include "SysProgressDlg.h"
  66 #include "UserPassword.h"
  67 #include "Patch.h"
  68
  69 CAppUtils::CAppUtils(void)
  70 {
  71 }
  72
  73 CAppUtils::~CAppUtils(void)
  74 {
  75 }
  76
  77 bool CAppUtils::StashSave()
  78 {
  79         CStashSaveDlg dlg;
  80
  81         if (dlg.DoModal() == IDOK)
  82         {
  83                 CString cmd, out;
  84                 cmd = _T("git.exe stash save");
  85
  86                 if (CAppUtils::GetMsysgitVersion() >= 0x01070700)
  87                 {
  88                         if (dlg.m_bIncludeUntracked)
  89                                 cmd += _T(" --include-untracked");
  90                         else if (dlg.m_bAll)
  91                                 cmd += _T(" --all");
  92                 }
  93
  94                 if (!dlg.m_sMessage.IsEmpty())
  95                 {
  96                         CString message = dlg.m_sMessage;
  97                         message.Replace(_T("\""), _T("\"\""));
  98                         cmd += _T(" \"") + message + _T("\"");
  99                 }
 100
 101                 CSysProgressDlg sysProgressDlg;
 102                 sysProgressDlg.SetTitle(CString(MAKEINTRESOURCE(IDS_APPNAME)));
 103                 sysProgressDlg.SetLine(1, CString(MAKEINTRESOURCE(IDS_PROC_STASHRUNNING)));
 104                 sysProgressDlg.SetLine(2, CString(MAKEINTRESOURCE(IDS_PROGRESSWAIT)));
 105                 sysProgressDlg.SetShowProgressBar(false);
 106                 sysProgressDlg.SetCancelMsg(IDS_PROGRS_INFOFAILED);
 107                 sysProgressDlg.ShowModeless((HWND)NULL, true);
 108
 109                 if (g_Git.Run(cmd, &out, CP_UTF8))
 110                 {
 111                         sysProgressDlg.Stop();
 112                         CMessageBox::Show(NULL, CString(MAKEINTRESOURCE(IDS_PROC_STASHFAILED)) + _T("\n") + out, _T("TortoiseGit"), MB_OK | MB_ICONERROR);
 113                 }
 114                 else
 115                 {
 116                         sysProgressDlg.Stop();
 117                         CMessageBox::Show(NULL, CString(MAKEINTRESOURCE(IDS_PROC_STASHSUCCESS)) + _T("\n") + out, _T("TortoiseGit"), MB_OK | MB_ICONINFORMATION);
 118                         return true;
 119                 }
 120         }
 121         return false;
 122 }
 123
 124 bool CAppUtils::StashApply(CString ref, bool showChanges /* true */)
 125 {
 126         CString cmd,out;
 127         cmd = _T("git.exe stash apply ");
 128         if (ref.Find(_T("refs/")) == 0)
 129                 ref = ref.Mid(5);
 130         if (ref.Find(_T("stash{")) == 0)
 131                 ref = _T("stash@") + ref.Mid(5);
 132         cmd += ref;
 133
 134         CSysProgressDlg sysProgressDlg;
 135         sysProgressDlg.SetTitle(CString(MAKEINTRESOURCE(IDS_APPNAME)));
 136         sysProgressDlg.SetLine(1, CString(MAKEINTRESOURCE(IDS_PROC_STASHRUNNING)));
 137         sysProgressDlg.SetLine(2, CString(MAKEINTRESOURCE(IDS_PROGRESSWAIT)));
 138         sysProgressDlg.SetShowProgressBar(false);
 139         sysProgressDlg.SetCancelMsg(IDS_PROGRS_INFOFAILED);
 140         sysProgressDlg.ShowModeless((HWND)NULL, true);
 141
 142         int ret = g_Git.Run(cmd, &out, CP_UTF8);
 143
 144         sysProgressDlg.Stop();
 145
 146         bool hasConflicts = (out.Find(_T("CONFLICT")) >= 0);
 147         if (ret && !(ret == 1 && hasConflicts))
 148         {
 149                 CMessageBox::Show(NULL, CString(MAKEINTRESOURCE(IDS_PROC_STASHAPPLYFAILED)) + _T("\n") + out, _T("TortoiseGit"), MB_OK | MB_ICONERROR);
 150         }
 151         else
 152         {
 153                 CString message;
 154                 message.LoadString(IDS_PROC_STASHAPPLYSUCCESS);
 155                 if (hasConflicts)
 156                         message.LoadString(IDS_PROC_STASHAPPLYFAILEDCONFLICTS);
 157                 if (showChanges)
 158                 {
 159                         if(CMessageBox::Show(NULL,message + _T("\n") + CString(MAKEINTRESOURCE(IDS_SEECHANGES))
 160                                 ,_T("TortoiseGit"),MB_YESNO|MB_ICONINFORMATION) == IDYES)
 161                         {
 162                                 CChangedDlg dlg;
 163                                 dlg.m_pathList.AddPath(CTGitPath());
 164                                 dlg.DoModal();
 165                         }
 166                         return true;
 167                 }
 168                 else
 169                 {
 170                         CMessageBox::Show(NULL, message ,_T("TortoiseGit"), MB_OK | MB_ICONINFORMATION);
 171                         return true;
 172                 }
 173         }
 174         return false;
 175 }
 176
 177 bool CAppUtils::StashPop(bool showChanges /* true */)
 178 {
 179         CString cmd,out;
 180         cmd=_T("git.exe stash pop ");
 181
 182         CSysProgressDlg sysProgressDlg;
 183         sysProgressDlg.SetTitle(CString(MAKEINTRESOURCE(IDS_APPNAME)));
 184         sysProgressDlg.SetLine(1, CString(MAKEINTRESOURCE(IDS_PROC_STASHRUNNING)));
 185         sysProgressDlg.SetLine(2, CString(MAKEINTRESOURCE(IDS_PROGRESSWAIT)));
 186         sysProgressDlg.SetShowProgressBar(false);
 187         sysProgressDlg.SetCancelMsg(IDS_PROGRS_INFOFAILED);
 188         sysProgressDlg.ShowModeless((HWND)NULL, true);
 189
 190         int ret = g_Git.Run(cmd, &out, CP_UTF8);
 191
 192         sysProgressDlg.Stop();
 193
 194         bool hasConflicts = (out.Find(_T("CONFLICT")) >= 0);
 195         if (ret && !(ret == 1 && hasConflicts))
 196         {
 197                 CMessageBox::Show(NULL,CString(MAKEINTRESOURCE(IDS_PROC_STASHPOPFAILED)) + _T("\n") + out, _T("TortoiseGit"), MB_OK | MB_ICONERROR);
 198         }
 199         else
 200         {
 201                 CString message;
 202                 message.LoadString(IDS_PROC_STASHPOPSUCCESS);
 203                 if (hasConflicts)
 204                         message.LoadString(IDS_PROC_STASHPOPFAILEDCONFLICTS);
 205                 if (showChanges)
 206                 {
 207                         if(CMessageBox::Show(NULL,CString(message + _T("\n") + CString(MAKEINTRESOURCE(IDS_SEECHANGES)))
 208                                 ,_T("TortoiseGit"),MB_YESNO|MB_ICONINFORMATION) == IDYES)
 209                         {
 210                                 CChangedDlg dlg;
 211                                 dlg.m_pathList.AddPath(CTGitPath());
 212                                 dlg.DoModal();
 213                         }
 214                         return true;
 215                 }
 216                 else
 217                 {
 218                         CMessageBox::Show(NULL, message ,_T("TortoiseGit"), MB_OK | MB_ICONINFORMATION);
 219                         return true;
 220                 }
 221         }
 222         return false;
 223 }
 224
 225 bool CAppUtils::GetMimeType(const CTGitPath& /*file*/, CString& /*mimetype*/)
 226 {
 227 #if 0
 228         GitProperties props(file, GitRev::REV_WC, false);
 229         for (int i = 0; i < props.GetCount(); ++i)
 230         {
 231                 if (props.GetItemName(i).compare(_T("svn:mime-type"))==0)
 232                 {
 233                         mimetype = props.GetItemValue(i).c_str();
 234                         return true;
 235                 }
 236         }
 237 #endif
 238         return false;
 239 }
 240
 241 BOOL CAppUtils::StartExtMerge(
 242         const CTGitPath& basefile, const CTGitPath& theirfile, const CTGitPath& yourfile, const CTGitPath& mergedfile,
 243         const CString& basename, const CString& theirname, const CString& yourname, const CString& mergedname, bool bReadOnly)
 244 {
 245
 246         CRegString regCom = CRegString(_T("Software\\TortoiseGit\\Merge"));
 247         CString ext = mergedfile.GetFileExtension();
 248         CString com = regCom;
 249         bool bInternal = false;
 250
 251         CString mimetype;
 252         if (ext != "")
 253         {
 254                 // is there an extension specific merge tool?
 255                 CRegString mergetool(_T("Software\\TortoiseGit\\MergeTools\\") + ext.MakeLower());
 256                 if (CString(mergetool) != "")
 257                 {
 258                         com = mergetool;
 259                 }
 260         }
 261         if (GetMimeType(yourfile, mimetype) || GetMimeType(theirfile, mimetype) || GetMimeType(basefile, mimetype))
 262         {
 263                 // is there a mime type specific merge tool?
 264                 CRegString mergetool(_T("Software\\TortoiseGit\\MergeTools\\") + mimetype);
 265                 if (CString(mergetool) != "")
 266                 {
 267                         com = mergetool;
 268                 }
 269         }
 270         // is there a filename specific merge tool?
 271         CRegString mergetool(_T("Software\\TortoiseGit\\MergeTools\\.") + mergedfile.GetFilename().MakeLower());
 272         if (CString(mergetool) != "")
 273         {
 274                 com = mergetool;
 275         }
 276
 277         // Maybe we should use TortoiseIDiff?
 278         if ((ext == _T(".jpg")) || (ext == _T(".jpeg")) ||
 279                 (ext == _T(".bmp")) || (ext == _T(".gif"))  ||
 280                 (ext == _T(".png")) || (ext == _T(".ico"))  ||
 281                 (ext == _T(".dib")) || (ext == _T(".emf")))
 282         {
 283                 com = _T("\"") + CPathUtils::GetAppDirectory() + _T("TortoiseGitIDiff.exe") + _T("\"") +
 284                         _T(" /left:%base /right:%mine /lefttitle:%bname /righttitle:%yname") + _T("\n") +
 285                         // delimited by \n
 286                         _T("\"") + CPathUtils::GetAppDirectory() + _T("TortoiseGitIDiff.exe") + _T("\"") +
 287                         _T(" /left:%base /right:%theirs /lefttitle:%bname /righttitle:%tname");
 288         }
 289
 290         if (com.IsEmpty()||(com.Left(1).Compare(_T("#"))==0))
 291         {
 292                 // use TortoiseGitMerge
 293                 bInternal = true;
 294                 CRegString tortoiseMergePath(_T("Software\\TortoiseGit\\TMergePath"), _T(""), false, HKEY_LOCAL_MACHINE);
 295                 com = tortoiseMergePath;
 296                 if (com.IsEmpty())
 297                 {
 298                         com = CPathUtils::GetAppDirectory();
 299                         com += _T("TortoiseGitMerge.exe");
 300                 }
 301                 com = _T("\"") + com + _T("\"");
 302                 if (!g_sGroupingUUID.IsEmpty())
 303                 {
 304                         com += L" /groupuuid:\"";
 305                         com += g_sGroupingUUID;
 306                         com += L"\"";
 307                 }
 308                 com = com + _T(" /base:%base /theirs:%theirs /mine:%mine /merged:%merged");
 309                 com = com + _T(" /basename:%bname /theirsname:%tname /minename:%yname /mergedname:%mname");
 310         }
 311         // check if the params are set. If not, just add the files to the command line
 312         if ((com.Find(_T("%merged"))<0)&&(com.Find(_T("%base"))<0)&&(com.Find(_T("%theirs"))<0)&&(com.Find(_T("%mine"))<0))
 313         {
 314                 com += _T(" \"")+basefile.GetWinPathString()+_T("\"");
 315                 com += _T(" \"")+theirfile.GetWinPathString()+_T("\"");
 316                 com += _T(" \"")+yourfile.GetWinPathString()+_T("\"");
 317                 com += _T(" \"")+mergedfile.GetWinPathString()+_T("\"");
 318         }
 319         if (basefile.IsEmpty())
 320         {
 321                 com.Replace(_T("/base:%base"), _T(""));
 322                 com.Replace(_T("%base"), _T(""));
 323         }
 324         else
 325                 com.Replace(_T("%base"), _T("\"") + basefile.GetWinPathString() + _T("\""));
 326         if (theirfile.IsEmpty())
 327         {
 328                 com.Replace(_T("/theirs:%theirs"), _T(""));
 329                 com.Replace(_T("%theirs"), _T(""));
 330         }
 331         else
 332                 com.Replace(_T("%theirs"), _T("\"") + theirfile.GetWinPathString() + _T("\""));
 333         if (yourfile.IsEmpty())
 334         {
 335                 com.Replace(_T("/mine:%mine"), _T(""));
 336                 com.Replace(_T("%mine"), _T(""));
 337         }
 338         else
 339                 com.Replace(_T("%mine"), _T("\"") + yourfile.GetWinPathString() + _T("\""));
 340         if (mergedfile.IsEmpty())
 341         {
 342                 com.Replace(_T("/merged:%merged"), _T(""));
 343                 com.Replace(_T("%merged"), _T(""));
 344         }
 345         else
 346                 com.Replace(_T("%merged"), _T("\"") + mergedfile.GetWinPathString() + _T("\""));
 347         if (basename.IsEmpty())
 348         {
 349                 if (basefile.IsEmpty())
 350                 {
 351                         com.Replace(_T("/basename:%bname"), _T(""));
 352                         com.Replace(_T("%bname"), _T(""));
 353                 }
 354                 else
 355                 {
 356                         com.Replace(_T("%bname"), _T("\"") + basefile.GetUIFileOrDirectoryName() + _T("\""));
 357                 }
 358         }
 359         else
 360                 com.Replace(_T("%bname"), _T("\"") + basename + _T("\""));
 361         if (theirname.IsEmpty())
 362         {
 363                 if (theirfile.IsEmpty())
 364                 {
 365                         com.Replace(_T("/theirsname:%tname"), _T(""));
 366                         com.Replace(_T("%tname"), _T(""));
 367                 }
 368                 else
 369                 {
 370                         com.Replace(_T("%tname"), _T("\"") + theirfile.GetUIFileOrDirectoryName() + _T("\""));
 371                 }
 372         }
 373         else
 374                 com.Replace(_T("%tname"), _T("\"") + theirname + _T("\""));
 375         if (yourname.IsEmpty())
 376         {
 377                 if (yourfile.IsEmpty())
 378                 {
 379                         com.Replace(_T("/minename:%yname"), _T(""));
 380                         com.Replace(_T("%yname"), _T(""));
 381                 }
 382                 else
 383                 {
 384                         com.Replace(_T("%yname"), _T("\"") + yourfile.GetUIFileOrDirectoryName() + _T("\""));
 385                 }
 386         }
 387         else
 388                 com.Replace(_T("%yname"), _T("\"") + yourname + _T("\""));
 389         if (mergedname.IsEmpty())
 390         {
 391                 if (mergedfile.IsEmpty())
 392                 {
 393                         com.Replace(_T("/mergedname:%mname"), _T(""));
 394                         com.Replace(_T("%mname"), _T(""));
 395                 }
 396                 else
 397                 {
 398                         com.Replace(_T("%mname"), _T("\"") + mergedfile.GetUIFileOrDirectoryName() + _T("\""));
 399                 }
 400         }
 401         else
 402                 com.Replace(_T("%mname"), _T("\"") + mergedname + _T("\""));
 403
 404         if ((bReadOnly)&&(bInternal))
 405                 com += _T(" /readonly");
 406
 407         CString com2;
 408         int newLine = com.Find(_T('\n'));
 409         if (newLine >= 0)
 410         {
 411                 com2 = com.Mid(newLine + 1);
 412                 com = com.Left(newLine);
 413         }
 414         if(!LaunchApplication(com, IDS_ERR_EXTMERGESTART, false))
 415         {
 416                 return FALSE;
 417         }
 418         if (!com2.IsEmpty() && !LaunchApplication(com2, IDS_ERR_EXTMERGESTART, false))
 419         {
 420                 return FALSE;
 421         }
 422
 423         return TRUE;
 424 }
 425
 426 BOOL CAppUtils::StartExtPatch(const CTGitPath& patchfile, const CTGitPath& dir, const CString& sOriginalDescription, const CString& sPatchedDescription, BOOL bReversed, BOOL bWait)
 427 {
 428         CString viewer;
 429         // use TortoiseGitMerge
 430         viewer = CPathUtils::GetAppDirectory();
 431         viewer += _T("TortoiseGitMerge.exe");
 432
 433         viewer = _T("\"") + viewer + _T("\"");
 434         viewer = viewer + _T(" /diff:\"") + patchfile.GetWinPathString() + _T("\"");
 435         viewer = viewer + _T(" /patchpath:\"") + dir.GetWinPathString() + _T("\"");
 436         if (bReversed)
 437                 viewer += _T(" /reversedpatch");
 438         if (!sOriginalDescription.IsEmpty())
 439                 viewer = viewer + _T(" /patchoriginal:\"") + sOriginalDescription + _T("\"");
 440         if (!sPatchedDescription.IsEmpty())
 441                 viewer = viewer + _T(" /patchpatched:\"") + sPatchedDescription + _T("\"");
 442         if (!g_sGroupingUUID.IsEmpty())
 443         {
 444                 viewer += L" /groupuuid:\"";
 445                 viewer += g_sGroupingUUID;
 446                 viewer += L"\"";
 447         }
 448         if(!LaunchApplication(viewer, IDS_ERR_DIFFVIEWSTART, !!bWait))
 449         {
 450                 return FALSE;
 451         }
 452         return TRUE;
 453 }
 454
 455 CString CAppUtils::PickDiffTool(const CTGitPath& file1, const CTGitPath& file2)
 456 {
 457         CString difftool = CRegString(_T("Software\\TortoiseGit\\DiffTools\\.") + file2.GetFilename().MakeLower());
 458         if (!difftool.IsEmpty())
 459                 return difftool;
 460         difftool = CRegString(_T("Software\\TortoiseGit\\DiffTools\\.") + file1.GetFilename().MakeLower());
 461         if (!difftool.IsEmpty())
 462                 return difftool;
 463
 464         // Is there a mime type specific diff tool?
 465         CString mimetype;
 466         if (GetMimeType(file1, mimetype) ||  GetMimeType(file2, mimetype))
 467         {
 468                 difftool = CRegString(_T("Software\\TortoiseGit\\DiffTools\\") + mimetype);
 469                 if (!difftool.IsEmpty())
 470                         return difftool;
 471         }
 472
 473         // Is there an extension specific diff tool?
 474         CString ext = file2.GetFileExtension().MakeLower();
 475         if (!ext.IsEmpty())
 476         {
 477                 difftool = CRegString(_T("Software\\TortoiseGit\\DiffTools\\") + ext);
 478                 if (!difftool.IsEmpty())
 479                         return difftool;
 480                 // Maybe we should use TortoiseIDiff?
 481                 if ((ext == _T(".jpg")) || (ext == _T(".jpeg")) ||
 482                         (ext == _T(".bmp")) || (ext == _T(".gif"))  ||
 483                         (ext == _T(".png")) || (ext == _T(".ico"))  ||
 484                         (ext == _T(".dib")) || (ext == _T(".emf")))
 485                 {
 486                         return
 487                                 _T("\"") + CPathUtils::GetAppDirectory() + _T("TortoiseGitIDiff.exe") + _T("\"") +
 488                                 _T(" /left:%base /right:%mine /lefttitle:%bname /righttitle:%yname") +
 489                                 L" /groupuuid:\"" + g_sGroupingUUID + L"\"";
 490                 }
 491         }
 492
 493         // Finally, pick a generic external diff tool
 494         difftool = CRegString(_T("Software\\TortoiseGit\\Diff"));
 495         return difftool;
 496 }
 497
 498 bool CAppUtils::StartExtDiff(
 499         const CString& file1,  const CString& file2,
 500         const CString& sName1, const CString& sName2,
 501         const CString& originalFile1, const CString& originalFile2,
 502         const git_revnum_t& hash1, const git_revnum_t& hash2,
 503         const DiffFlags& flags)
 504 {
 505         CString viewer;
 506
 507         CRegDWORD blamediff(_T("Software\\TortoiseGit\\DiffBlamesWithTortoiseMerge"), FALSE);
 508         if (!flags.bBlame || !(DWORD)blamediff)
 509         {
 510                 viewer = PickDiffTool(file1, file2);
 511                 // If registry entry for a diff program is commented out, use TortoiseGitMerge.
 512                 bool bCommentedOut = viewer.Left(1) == _T("#");
 513                 if (flags.bAlternativeTool)
 514                 {
 515                         // Invert external vs. internal diff tool selection.
 516                         if (bCommentedOut)
 517                                 viewer.Delete(0); // uncomment
 518                         else
 519                                 viewer = "";
 520                 }
 521                 else if (bCommentedOut)
 522                         viewer = "";
 523         }
 524
 525         bool bInternal = viewer.IsEmpty();
 526         if (bInternal)
 527         {
 528                 viewer =
 529                         _T("\"") + CPathUtils::GetAppDirectory() + _T("TortoiseGitMerge.exe") + _T("\"") +
 530                         _T(" /base:%base /mine:%mine /basename:%bname /minename:%yname");
 531                 if (!g_sGroupingUUID.IsEmpty())
 532                 {
 533                         viewer += L" /groupuuid:\"";
 534                         viewer += g_sGroupingUUID;
 535                         viewer += L"\"";
 536                 }
 537                 if (flags.bBlame)
 538                         viewer += _T(" /blame");
 539         }
 540         // check if the params are set. If not, just add the files to the command line
 541         if ((viewer.Find(_T("%base"))<0)&&(viewer.Find(_T("%mine"))<0))
 542         {
 543                 viewer += _T(" \"")+file1+_T("\"");
 544                 viewer += _T(" \"")+file2+_T("\"");
 545         }
 546         if (viewer.Find(_T("%base")) >= 0)
 547         {
 548                 viewer.Replace(_T("%base"),  _T("\"")+file1+_T("\""));
 549         }
 550         if (viewer.Find(_T("%mine")) >= 0)
 551         {
 552                 viewer.Replace(_T("%mine"),  _T("\"")+file2+_T("\""));
 553         }
 554
 555         if (sName1.IsEmpty())
 556                 viewer.Replace(_T("%bname"), _T("\"") + file1 + _T("\""));
 557         else
 558                 viewer.Replace(_T("%bname"), _T("\"") + sName1 + _T("\""));
 559
 560         if (sName2.IsEmpty())
 561                 viewer.Replace(_T("%yname"), _T("\"") + file2 + _T("\""));
 562         else
 563                 viewer.Replace(_T("%yname"), _T("\"") + sName2 + _T("\""));
 564
 565         viewer.Replace(_T("%bpath"), _T("\"") + originalFile1 + _T("\""));
 566         viewer.Replace(_T("%ypath"), _T("\"") + originalFile2 + _T("\""));
 567
 568         viewer.Replace(_T("%brev"), _T("\"") + hash1 + _T("\""));
 569         viewer.Replace(_T("%yrev"), _T("\"") + hash2 + _T("\""));
 570
 571         if (flags.bReadOnly && bInternal)
 572                 viewer += _T(" /readonly");
 573
 574         return LaunchApplication(viewer, IDS_ERR_EXTDIFFSTART, flags.bWait);
 575 }
 576
 577 BOOL CAppUtils::StartUnifiedDiffViewer(const CString& patchfile, const CString& title, BOOL bWait)
 578 {
 579         CString viewer;
 580         CRegString v = CRegString(_T("Software\\TortoiseGit\\DiffViewer"));
 581         viewer = v;
 582         if (viewer.IsEmpty() || (viewer.Left(1).Compare(_T("#"))==0))
 583         {
 584                 // use TortoiseGitUDiff
 585                 viewer = CPathUtils::GetAppDirectory();
 586                 viewer += _T("TortoiseGitUDiff.exe");
 587                 // enquote the path to TortoiseGitUDiff
 588                 viewer = _T("\"") + viewer + _T("\"");
 589                 // add the params
 590                 viewer = viewer + _T(" /patchfile:%1 /title:\"%title\"");
 591                 if (!g_sGroupingUUID.IsEmpty())
 592                 {
 593                         viewer += L" /groupuuid:\"";
 594                         viewer += g_sGroupingUUID;
 595                         viewer += L"\"";
 596                 }
 597         }
 598         if (viewer.Find(_T("%1"))>=0)
 599         {
 600                 if (viewer.Find(_T("\"%1\"")) >= 0)
 601                         viewer.Replace(_T("%1"), patchfile);
 602                 else
 603                         viewer.Replace(_T("%1"), _T("\"") + patchfile + _T("\""));
 604         }
 605         else
 606                 viewer += _T(" \"") + patchfile + _T("\"");
 607         if (viewer.Find(_T("%title")) >= 0)
 608         {
 609                 viewer.Replace(_T("%title"), title);
 610         }
 611
 612         if(!LaunchApplication(viewer, IDS_ERR_DIFFVIEWSTART, !!bWait))
 613         {
 614                 return FALSE;
 615         }
 616         return TRUE;
 617 }
 618
 619 BOOL CAppUtils::StartTextViewer(CString file)
 620 {
 621         CString viewer;
 622         CRegString txt = CRegString(_T(".txt\\"), _T(""), FALSE, HKEY_CLASSES_ROOT);
 623         viewer = txt;
 624         viewer = viewer + _T("\\Shell\\Open\\Command\\");
 625         CRegString txtexe = CRegString(viewer, _T(""), FALSE, HKEY_CLASSES_ROOT);
 626         viewer = txtexe;
 627
 628         DWORD len = ExpandEnvironmentStrings(viewer, NULL, 0);
 629         std::unique_ptr<TCHAR[]> buf(new TCHAR[len + 1]);
 630         ExpandEnvironmentStrings(viewer, buf.get(), len);
 631         viewer = buf.get();
 632         len = ExpandEnvironmentStrings(file, NULL, 0);
 633         std::unique_ptr<TCHAR[]> buf2(new TCHAR[len + 1]);
 634         ExpandEnvironmentStrings(file, buf2.get(), len);
 635         file = buf2.get();
 636         file = _T("\"")+file+_T("\"");
 637         if (viewer.IsEmpty())
 638         {
 639                 viewer = _T("RUNDLL32 Shell32,OpenAs_RunDLL");
 640         }
 641         if (viewer.Find(_T("\"%1\"")) >= 0)
 642         {
 643                 viewer.Replace(_T("\"%1\""), file);
 644         }
 645         else if (viewer.Find(_T("%1")) >= 0)
 646         {
 647                 viewer.Replace(_T("%1"),  file);
 648         }
 649         else
 650         {
 651                 viewer += _T(" ");
 652                 viewer += file;
 653         }
 654
 655         if(!LaunchApplication(viewer, IDS_ERR_TEXTVIEWSTART, false))
 656         {
 657                 return FALSE;
 658         }
 659         return TRUE;
 660 }
 661
 662 BOOL CAppUtils::CheckForEmptyDiff(const CTGitPath& sDiffPath)
 663 {
 664         DWORD length = 0;
 665         CAutoFile hFile = ::CreateFile(sDiffPath.GetWinPath(), GENERIC_READ, FILE_SHARE_READ | FILE_SHARE_WRITE, NULL, OPEN_EXISTING, NULL, NULL);
 666         if (!hFile)
 667                 return TRUE;
 668         length = ::GetFileSize(hFile, NULL);
 669         if (length < 4)
 670                 return TRUE;
 671         return FALSE;
 672
 673 }
 674
 675 void CAppUtils::CreateFontForLogs(CFont& fontToCreate)
 676 {
 677         LOGFONT logFont;
 678         HDC hScreenDC = ::GetDC(NULL);
 679         logFont.lfHeight                        = -MulDiv((DWORD)CRegDWORD(_T("Software\\TortoiseGit\\LogFontSize"), 8), GetDeviceCaps(hScreenDC, LOGPIXELSY), 72);
 680         ::ReleaseDC(NULL, hScreenDC);
 681         logFont.lfWidth                         = 0;
 682         logFont.lfEscapement            = 0;
 683         logFont.lfOrientation           = 0;
 684         logFont.lfWeight                        = FW_NORMAL;
 685         logFont.lfItalic                        = 0;
 686         logFont.lfUnderline                     = 0;
 687         logFont.lfStrikeOut                     = 0;
 688         logFont.lfCharSet                       = DEFAULT_CHARSET;
 689         logFont.lfOutPrecision          = OUT_DEFAULT_PRECIS;
 690         logFont.lfClipPrecision         = CLIP_DEFAULT_PRECIS;
 691         logFont.lfQuality                       = DRAFT_QUALITY;
 692         logFont.lfPitchAndFamily        = FF_DONTCARE | FIXED_PITCH;
 693         _tcscpy_s(logFont.lfFaceName, 32, (LPCTSTR)(CString)CRegString(_T("Software\\TortoiseGit\\LogFontName"), _T("Courier New")));
 694         VERIFY(fontToCreate.CreateFontIndirect(&logFont));
 695 }
 696
 697 bool CAppUtils::LaunchPAgent(CString *keyfile,CString * pRemote)
 698 {
 699         CString key,remote;
 700         CString cmd,out;
 701         if( pRemote == NULL)
 702         {
 703                 remote=_T("origin");
 704         }
 705         else
 706         {
 707                 remote=*pRemote;
 708         }
 709         if(keyfile == NULL)
 710         {
 711                 cmd.Format(_T("remote.%s.puttykeyfile"),remote);
 712                 key = g_Git.GetConfigValue(cmd);
 713                 int start=0;
 714                 key = key.Tokenize(_T("\n"),start);
 715         }
 716         else
 717                 key=*keyfile;
 718
 719         if(key.IsEmpty())
 720                 return false;
 721
 722         CString proc=CPathUtils::GetAppDirectory();
 723         proc += _T("pageant.exe \"");
 724         proc += key;
 725         proc += _T("\"");
 726
 727         CString tempfile = GetTempFile();
 728         ::DeleteFile(tempfile);
 729
 730         proc += _T(" -c \"");
 731         proc += CPathUtils::GetAppDirectory();
 732         proc += _T("touch.exe\"");
 733         proc += _T(" \"");
 734         proc += tempfile;
 735         proc += _T("\"");
 736
 737         CString appDir = CPathUtils::GetAppDirectory();
 738         bool b = LaunchApplication(proc, IDS_ERR_PAGEANT, true, &appDir);
 739         if(!b)
 740                 return b;
 741
 742         int i=0;
 743         while(!::PathFileExists(tempfile))
 744         {
 745                 Sleep(100);
 746                 ++i;
 747                 if(i>10*60*5)
 748                         break; //timeout 5 minutes
 749         }
 750
 751         if( i== 10*60*5)
 752         {
 753                 CMessageBox::Show(NULL, IDS_ERR_PAEGENTTIMEOUT, IDS_APPNAME, MB_OK | MB_ICONERROR);
 754         }
 755         ::DeleteFile(tempfile);
 756         return true;
 757 }
 758 bool CAppUtils::LaunchAlternativeEditor(const CString& filename, bool uac)
 759 {
 760         CString editTool = CRegString(_T("Software\\TortoiseGit\\AlternativeEditor"));
 761         if (editTool.IsEmpty() || (editTool.Left(1).Compare(_T("#"))==0)) {
 762                 editTool = CPathUtils::GetAppDirectory() + _T("notepad2.exe");
 763         }
 764
 765         CString sCmd;
 766         sCmd.Format(_T("\"%s\" \"%s\""), editTool, filename);
 767
 768         LaunchApplication(sCmd, NULL, false, NULL, uac);
 769         return true;
 770 }
 771 bool CAppUtils::LaunchRemoteSetting()
 772 {
 773         CTGitPath path(g_Git.m_CurrentDir);
 774         CSettings dlg(IDS_PROC_SETTINGS_TITLE, &path);
 775         dlg.SetTreeViewMode(TRUE, TRUE, TRUE);
 776         dlg.SetTreeWidth(220);
 777         dlg.m_DefaultPage = _T("gitremote");
 778
 779         dlg.DoModal();
 780         dlg.HandleRestart();
 781         return true;
 782 }
 783 /**
 784 * Launch the external blame viewer
 785 */
 786 bool CAppUtils::LaunchTortoiseBlame(const CString& sBlameFile,CString Rev,const CString& sParams)
 787 {
 788         CString viewer = _T("\"") + CPathUtils::GetAppDirectory();
 789         viewer += _T("TortoiseGitBlame.exe");
 790         viewer += _T("\" \"") + sBlameFile + _T("\"");
 791         //viewer += _T(" \"") + sLogFile + _T("\"");
 792         //viewer += _T(" \"") + sOriginalFile + _T("\"");
 793         if(!Rev.IsEmpty() && Rev != GIT_REV_ZERO)
 794                 viewer += CString(_T(" /rev:"))+Rev;
 795         if (!g_sGroupingUUID.IsEmpty())
 796         {
 797                 viewer += L" /groupuuid:\"";
 798                 viewer += g_sGroupingUUID;
 799                 viewer += L"\"";
 800         }
 801         viewer += _T(" ")+sParams;
 802
 803         return LaunchApplication(viewer, IDS_ERR_TGITBLAME, false);
 804 }
 805
 806 bool CAppUtils::FormatTextInRichEditControl(CWnd * pWnd)
 807 {
 808         CString sText;
 809         if (pWnd == NULL)
 810                 return false;
 811         bool bStyled = false;
 812         pWnd->GetWindowText(sText);
 813         // the rich edit control doesn't count the CR char!
 814         // to be exact: CRLF is treated as one char.
 815         sText.Remove('\r');
 816
 817         // style each line separately
 818         int offset = 0;
 819         int nNewlinePos;
 820         do
 821         {
 822                 nNewlinePos = sText.Find('\n', offset);
 823                 CString sLine = sText.Mid(offset);
 824                 if (nNewlinePos>=0)
 825                         sLine = sLine.Left(nNewlinePos-offset);
 826                 int start = 0;
 827                 int end = 0;
 828                 while (FindStyleChars(sLine, '*', start, end))
 829                 {
 830                         CHARRANGE range = {(LONG)start+offset, (LONG)end+offset};
 831                         pWnd->SendMessage(EM_EXSETSEL, NULL, (LPARAM)&range);
 832                         CHARFORMAT2 format;
 833                         SecureZeroMemory(&format, sizeof(CHARFORMAT2));
 834                         format.cbSize = sizeof(CHARFORMAT2);
 835                         format.dwMask = CFM_BOLD;
 836                         format.dwEffects = CFE_BOLD;
 837                         pWnd->SendMessage(EM_SETCHARFORMAT, SCF_SELECTION, (LPARAM)&format);
 838                         bStyled = true;
 839                         start = end;
 840                 }
 841                 start = 0;
 842                 end = 0;
 843                 while (FindStyleChars(sLine, '^', start, end))
 844                 {
 845                         CHARRANGE range = {(LONG)start+offset, (LONG)end+offset};
 846                         pWnd->SendMessage(EM_EXSETSEL, NULL, (LPARAM)&range);
 847                         CHARFORMAT2 format;
 848                         SecureZeroMemory(&format, sizeof(CHARFORMAT2));
 849                         format.cbSize = sizeof(CHARFORMAT2);
 850                         format.dwMask = CFM_ITALIC;
 851                         format.dwEffects = CFE_ITALIC;
 852                         pWnd->SendMessage(EM_SETCHARFORMAT, SCF_SELECTION, (LPARAM)&format);
 853                         bStyled = true;
 854                         start = end;
 855                 }
 856                 start = 0;
 857                 end = 0;
 858                 while (FindStyleChars(sLine, '_', start, end))
 859                 {
 860                         CHARRANGE range = {(LONG)start+offset, (LONG)end+offset};
 861                         pWnd->SendMessage(EM_EXSETSEL, NULL, (LPARAM)&range);
 862                         CHARFORMAT2 format;
 863                         SecureZeroMemory(&format, sizeof(CHARFORMAT2));
 864                         format.cbSize = sizeof(CHARFORMAT2);
 865                         format.dwMask = CFM_UNDERLINE;
 866                         format.dwEffects = CFE_UNDERLINE;
 867                         pWnd->SendMessage(EM_SETCHARFORMAT, SCF_SELECTION, (LPARAM)&format);
 868                         bStyled = true;
 869                         start = end;
 870                 }
 871                 offset = nNewlinePos+1;
 872         } while(nNewlinePos>=0);
 873         return bStyled;
 874 }
 875
 876 bool CAppUtils::FindStyleChars(const CString& sText, TCHAR stylechar, int& start, int& end)
 877 {
 878         int i=start;
 879         bool bFoundMarker = false;
 880         // find a starting marker
 881         while (sText[i] != 0)
 882         {
 883                 if (sText[i] == stylechar)
 884                 {
 885                         if (((i+1)<sText.GetLength())&&(IsCharAlphaNumeric(sText[i+1])) &&
 886                                 (((i>0)&&(!IsCharAlphaNumeric(sText[i-1])))||(i==0)))
 887                         {
 888                                 start = i+1;
 889                                 ++i;
 890                                 bFoundMarker = true;
 891                                 break;
 892                         }
 893                 }
 894                 ++i;
 895         }
 896         if (!bFoundMarker)
 897                 return false;
 898         // find ending marker
 899         bFoundMarker = false;
 900         while (sText[i] != 0)
 901         {
 902                 if (sText[i] == stylechar)
 903                 {
 904                         if ((IsCharAlphaNumeric(sText[i-1])) &&
 905                                 ((((i+1)<sText.GetLength())&&(!IsCharAlphaNumeric(sText[i+1])))||(i+1)==sText.GetLength()))
 906                         {
 907                                 end = i;
 908                                 ++i;
 909                                 bFoundMarker = true;
 910                                 break;
 911                         }
 912                 }
 913                 ++i;
 914         }
 915         return bFoundMarker;
 916 }
 917
 918 CString CAppUtils::GetProjectNameFromURL(CString url)
 919 {
 920         CString name;
 921         while (name.IsEmpty() || (name.CompareNoCase(_T("branches"))==0) ||
 922                 (name.CompareNoCase(_T("tags"))==0) ||
 923                 (name.CompareNoCase(_T("trunk"))==0))
 924         {
 925                 name = url.Mid(url.ReverseFind('/')+1);
 926                 url = url.Left(url.ReverseFind('/'));
 927         }
 928         if ((name.Compare(_T("svn")) == 0)||(name.Compare(_T("svnroot")) == 0))
 929         {
 930                 // a name of svn or svnroot indicates that it's not really the project name. In that
 931                 // case, we try the first part of the URL
 932                 // of course, this won't work in all cases (but it works for Google project hosting)
 933                 url.Replace(_T("http://"), _T(""));
 934                 url.Replace(_T("https://"), _T(""));
 935                 url.Replace(_T("svn://"), _T(""));
 936                 url.Replace(_T("svn+ssh://"), _T(""));
 937                 url.TrimLeft(_T("/"));
 938                 name = url.Left(url.Find('.'));
 939         }
 940         return name;
 941 }
 942
 943 bool CAppUtils::StartShowUnifiedDiff(HWND /*hWnd*/, const CTGitPath& url1, const git_revnum_t& rev1,
 944                                                                                                 const CTGitPath& /*url2*/, const git_revnum_t& rev2,
 945                                                                                                 //const GitRev& peg /* = GitRev */, const GitRev& headpeg /* = GitRev */,
 946                                                                                                 bool /*bAlternateDiff*/ /* = false */, bool /*bIgnoreAncestry*/ /* = false */, bool /* blame = false */, bool bMerge)
 947 {
 948
 949         CString tempfile=GetTempFile();
 950         CString cmd;
 951         if(rev2 == GitRev::GetWorkingCopy())
 952         {
 953                 cmd.Format(_T("git.exe diff --stat -p %s "), rev1);
 954         }
 955         else if (rev1 == GitRev::GetWorkingCopy())
 956         {
 957                 cmd.Format(_T("git.exe diff -R --stat -p %s "), rev2);
 958         }
 959         else
 960         {
 961                 CString merge;
 962                 if(bMerge)
 963                                 merge = _T("-c");
 964
 965                 cmd.Format(_T("git.exe diff-tree -r -p %s --stat %s %s"),merge, rev1,rev2);
 966         }
 967
 968         if( !url1.IsEmpty() )
 969         {
 970                 cmd += _T(" -- \"");
 971                 cmd += url1.GetGitPathString();
 972                 cmd += _T("\" ");
 973         }
 974         g_Git.RunLogFile(cmd,tempfile);
 975         CAppUtils::StartUnifiedDiffViewer(tempfile, rev1 + _T(":") + rev2);
 976
 977
 978 #if 0
 979         CString sCmd;
 980         sCmd.Format(_T("%s /command:showcompare /unified"),
 981                 (LPCTSTR)(CPathUtils::GetAppDirectory()+_T("TortoiseGitProc.exe")));
 982         sCmd += _T(" /url1:\"") + url1.GetGitPathString() + _T("\"");
 983         if (rev1.IsValid())
 984                 sCmd += _T(" /revision1:") + rev1.ToString();
 985         sCmd += _T(" /url2:\"") + url2.GetGitPathString() + _T("\"");
 986         if (rev2.IsValid())
 987                 sCmd += _T(" /revision2:") + rev2.ToString();
 988         if (peg.IsValid())
 989                 sCmd += _T(" /pegrevision:") + peg.ToString();
 990         if (headpeg.IsValid())
 991                 sCmd += _T(" /headpegrevision:") + headpeg.ToString();
 992
 993         if (bAlternateDiff)
 994                 sCmd += _T(" /alternatediff");
 995
 996         if (bIgnoreAncestry)
 997                 sCmd += _T(" /ignoreancestry");
 998
 999         if (hWnd)
1000         {
1001                 sCmd += _T(" /hwnd:");
1002                 TCHAR buf[30];
1003                 _stprintf_s(buf, 30, _T("%d"), hWnd);
1004                 sCmd += buf;
1005         }
1006
1007         return CAppUtils::LaunchApplication(sCmd, NULL, false);
1008 #endif
1009         return TRUE;
1010 }
1011
1012 bool CAppUtils::SetupDiffScripts(bool force, const CString& type)
1013 {
1014         CString scriptsdir = CPathUtils::GetAppParentDirectory();
1015         scriptsdir += _T("Diff-Scripts");
1016         CSimpleFileFind files(scriptsdir);
1017         while (files.FindNextFileNoDirectories())
1018         {
1019                 CString file = files.GetFilePath();
1020                 CString filename = files.GetFileName();
1021                 CString ext = file.Mid(file.ReverseFind('-') + 1);
1022                 ext = _T(".") + ext.Left(ext.ReverseFind('.'));
1023                 std::set<CString> extensions;
1024                 extensions.insert(ext);
1025                 CString kind;
1026                 if (file.Right(3).CompareNoCase(_T("vbs"))==0)
1027                 {
1028                         kind = _T(" //E:vbscript");
1029                 }
1030                 if (file.Right(2).CompareNoCase(_T("js"))==0)
1031                 {
1032                         kind = _T(" //E:javascript");
1033                 }
1034                 // open the file, read the first line and find possible extensions
1035                 // this script can handle
1036                 try
1037                 {
1038                         CStdioFile f(file, CFile::modeRead | CFile::shareDenyNone);
1039                         CString extline;
1040                         if (f.ReadString(extline))
1041                         {
1042                                 if ((extline.GetLength() > 15 ) &&
1043                                         ((extline.Left(15).Compare(_T("// extensions: ")) == 0) ||
1044                                         (extline.Left(14).Compare(_T("' extensions: ")) == 0)))
1045                                 {
1046                                         if (extline[0] == '/')
1047                                                 extline = extline.Mid(15);
1048                                         else
1049                                                 extline = extline.Mid(14);
1050                                         CString sToken;
1051                                         int curPos = 0;
1052                                         sToken = extline.Tokenize(_T(";"), curPos);
1053                                         while (!sToken.IsEmpty())
1054                                         {
1055                                                 if (!sToken.IsEmpty())
1056                                                 {
1057                                                         if (sToken[0] != '.')
1058                                                                 sToken = _T(".") + sToken;
1059                                                         extensions.insert(sToken);
1060                                                 }
1061                                                 sToken = extline.Tokenize(_T(";"), curPos);
1062                                         }
1063                                 }
1064                         }
1065                         f.Close();
1066                 }
1067                 catch (CFileException* e)
1068                 {
1069                         e->Delete();
1070                 }
1071
1072                 for (std::set<CString>::const_iterator it = extensions.begin(); it != extensions.end(); ++it)
1073                 {
1074                         if (type.IsEmpty() || (type.Compare(_T("Diff")) == 0))
1075                         {
1076                                 if (filename.Left(5).CompareNoCase(_T("diff-")) == 0)
1077                                 {
1078                                         CRegString diffreg = CRegString(_T("Software\\TortoiseGit\\DiffTools\\") + *it);
1079                                         CString diffregstring = diffreg;
1080                                         if (force || (diffregstring.IsEmpty()) || (diffregstring.Find(filename) >= 0))
1081                                                 diffreg = _T("wscript.exe \"") + file + _T("\" %base %mine") + kind;
1082                                 }
1083                         }
1084                         if (type.IsEmpty() || (type.Compare(_T("Merge"))==0))
1085                         {
1086                                 if (filename.Left(6).CompareNoCase(_T("merge-"))==0)
1087                                 {
1088                                         CRegString diffreg = CRegString(_T("Software\\TortoiseGit\\MergeTools\\") + *it);
1089                                         CString diffregstring = diffreg;
1090                                         if (force || (diffregstring.IsEmpty()) || (diffregstring.Find(filename) >= 0))
1091                                                 diffreg = _T("wscript.exe \"") + file + _T("\" %merged %theirs %mine %base") + kind;
1092                                 }
1093                         }
1094                 }
1095         }
1096
1097         return true;
1098 }
1099
1100 bool CAppUtils::Export(CString *BashHash)
1101 {
1102                 // ask from where the export has to be done
1103         CExportDlg dlg;
1104         if(BashHash)
1105                 dlg.m_Revision=*BashHash;
1106
1107         if (dlg.DoModal() == IDOK)
1108         {
1109                 CString cmd;
1110                 cmd.Format(_T("git.exe archive --output=\"%s\" --format=zip --verbose %s"),
1111                                         dlg.m_strExportDirectory, g_Git.FixBranchName(dlg.m_VersionName));
1112
1113                 CProgressDlg pro;
1114                 pro.m_GitCmd=cmd;
1115                 return (pro.DoModal() == IDOK);
1116         }
1117         return false;
1118 }
1119
1120 bool CAppUtils::CreateBranchTag(bool IsTag,CString *CommitHash, bool switch_new_brach)
1121 {
1122         CCreateBranchTagDlg dlg;
1123         dlg.m_bIsTag=IsTag;
1124         dlg.m_bSwitch=switch_new_brach;
1125
1126         if(CommitHash)
1127                 dlg.m_initialRefName = *CommitHash;
1128
1129         if(dlg.DoModal()==IDOK)
1130         {
1131                 CString cmd;
1132                 CString force;
1133                 CString track;
1134                 if(dlg.m_bTrack == TRUE)
1135                         track=_T(" --track ");
1136                 else if(dlg.m_bTrack == FALSE)
1137                         track=_T(" --no-track");
1138
1139                 if(dlg.m_bForce)
1140                         force=_T(" -f ");
1141
1142                 if(IsTag)
1143                 {
1144                         CString sign;
1145                         if(dlg.m_bSign)
1146                                 sign=_T("-s");
1147
1148                         cmd.Format(_T("git.exe tag %s %s %s %s"),
1149                                 force,
1150                                 sign,
1151                                 dlg.m_BranchTagName,
1152                                 g_Git.FixBranchName(dlg.m_VersionName)
1153                                 );
1154
1155                         CString tempfile=::GetTempFile();
1156                         if(!dlg.m_Message.Trim().IsEmpty())
1157                         {
1158                                 CAppUtils::SaveCommitUnicodeFile(tempfile,dlg.m_Message);
1159                                 cmd += _T(" -F ")+tempfile;
1160                         }
1161                 }
1162                 else
1163                 {
1164                         cmd.Format(_T("git.exe branch %s %s %s %s"),
1165                                 track,
1166                                 force,
1167                                 dlg.m_BranchTagName,
1168                                 g_Git.FixBranchName(dlg.m_VersionName)
1169                                 );
1170                 }
1171                 CString out;
1172                 if(g_Git.Run(cmd,&out,CP_UTF8))
1173                 {
1174                         CMessageBox::Show(NULL,out,_T("TortoiseGit"),MB_OK);
1175                         return FALSE;
1176                 }
1177                 if( !IsTag  &&  dlg.m_bSwitch )
1178                 {
1179                         // it is a new branch and the user has requested to switch to it
1180                         cmd.Format(_T("git.exe checkout %s"), dlg.m_BranchTagName);
1181                         g_Git.Run(cmd,&out,CP_UTF8);
1182                         CMessageBox::Show(NULL,out,_T("TortoiseGit"),MB_OK);
1183                 }
1184
1185                 return TRUE;
1186         }
1187         return FALSE;
1188 }
1189
1190 bool CAppUtils::Switch(CString initialRefName, bool autoclose)
1191 {
1192         CGitSwitchDlg dlg;
1193         if(!initialRefName.IsEmpty())
1194                 dlg.m_initialRefName = initialRefName;
1195
1196         if (dlg.DoModal() == IDOK)
1197         {
1198                 CString branch;
1199                 if (dlg.m_bBranch)
1200                         branch = dlg.m_NewBranch;
1201
1202                 // if refs/heads/ is not stripped, checkout will detach HEAD
1203                 // checkout prefers branches on name clashes (with tags)
1204                 if (dlg.m_VersionName.Left(11) ==_T("refs/heads/") && dlg.m_bBranchOverride != TRUE)
1205                         dlg.m_VersionName = dlg.m_VersionName.Mid(11);
1206
1207                 return PerformSwitch(dlg.m_VersionName, dlg.m_bForce == TRUE , branch, dlg.m_bBranchOverride == TRUE, dlg.m_bTrack, autoclose);
1208         }
1209         return FALSE;
1210 }
1211
1212 bool CAppUtils::PerformSwitch(CString ref, bool bForce /* false */, CString sNewBranch /* CString() */, bool bBranchOverride /* false */, BOOL bTrack /* 2 */, bool autoClose /* false */)
1213 {
1214         CString cmd;
1215         CString track;
1216         CString force;
1217         CString branch;
1218
1219         if(!sNewBranch.IsEmpty()){
1220                 if (bBranchOverride)
1221                 {
1222                         branch.Format(_T("-B %s"), sNewBranch);
1223                 }
1224                 else
1225                 {
1226                         branch.Format(_T("-b %s"), sNewBranch);
1227                 }
1228                 if (bTrack == TRUE)
1229                         track = _T("--track");
1230                 else if (bTrack == FALSE)
1231                         track = _T("--no-track");
1232         }
1233         if (bForce)
1234                 force = _T("-f");
1235
1236         cmd.Format(_T("git.exe checkout %s %s %s %s"),
1237                  force,
1238                  track,
1239                  branch,
1240                  g_Git.FixBranchName(ref));
1241
1242         CProgressDlg progress;
1243         progress.m_bAutoCloseOnSuccess = autoClose;
1244         progress.m_GitCmd = cmd;
1245
1246         CTGitPath gitPath = g_Git.m_CurrentDir;
1247         if (gitPath.HasSubmodules())
1248                 progress.m_PostCmdList.Add(CString(MAKEINTRESOURCE(IDS_PROC_SUBMODULESUPDATE)));
1249
1250         INT_PTR ret = progress.DoModal();
1251         if (gitPath.HasSubmodules() && ret == IDC_PROGRESS_BUTTON1)
1252         {
1253                 CString sCmd;
1254                 sCmd.Format(_T("/command:subupdate /bkpath:\"%s\""), g_Git.m_CurrentDir);
1255
1256                 RunTortoiseGitProc(sCmd);
1257                 return TRUE;
1258         }
1259         else if (ret == IDOK)
1260                 return TRUE;
1261
1262         return FALSE;
1263 }
1264
1265 bool CAppUtils::OpenIgnoreFile(CStdioFile &file, const CString& filename)
1266 {
1267         if (!file.Open(filename, CFile::modeCreate | CFile::modeReadWrite | CFile::modeNoTruncate))
1268         {
1269                 CMessageBox::Show(NULL, filename + _T(" Open Failure"), _T("TortoiseGit"), MB_OK | MB_ICONERROR);
1270                 return false;
1271         }
1272
1273         if (file.GetLength() > 0)
1274         {
1275                 file.Seek(file.GetLength() - 1, 0);
1276                 std::unique_ptr<TCHAR[]> buf(new TCHAR[1]);
1277                 file.Read(buf.get(), 1);
1278                 file.SeekToEnd();
1279                 if (buf.get()[0] != _T('\n'))
1280                         file.WriteString(_T("\n"));
1281         }
1282         else
1283                 file.SeekToEnd();
1284
1285         return true;
1286 }
1287
1288 bool CAppUtils::IgnoreFile(CTGitPathList &path,bool IsMask)
1289 {
1290         CIgnoreDlg ignoreDlg;
1291         if (ignoreDlg.DoModal() == IDOK)
1292         {
1293                 CString ignorefile;
1294                 ignorefile = g_Git.m_CurrentDir + _T("\\");
1295
1296                 switch (ignoreDlg.m_IgnoreFile)
1297                 {
1298                         case 0:
1299                                 ignorefile += _T(".gitignore");
1300                                 break;
1301                         case 2:
1302                                 g_GitAdminDir.GetAdminDirPath(g_Git.m_CurrentDir, ignorefile);
1303                                 ignorefile += _T("info/exclude");
1304                                 break;
1305                 }
1306
1307                 CStdioFile file;
1308                 try
1309                 {
1310                         if (ignoreDlg.m_IgnoreFile != 1 && !OpenIgnoreFile(file, ignorefile))
1311                                 return false;
1312
1313                         for (int i = 0; i < path.GetCount(); ++i)
1314                         {
1315                                 if (ignoreDlg.m_IgnoreFile == 1)
1316                                 {
1317                                         ignorefile = g_Git.m_CurrentDir + _T("\\") + path[i].GetContainingDirectory().GetWinPathString() + _T("\\.gitignore");
1318                                         if (!OpenIgnoreFile(file, ignorefile))
1319                                                 return false;
1320                                 }
1321
1322                                 CString ignorePattern;
1323                                 if (ignoreDlg.m_IgnoreType == 0)
1324                                 {
1325                                         if (ignoreDlg.m_IgnoreFile != 1 && !path[i].GetContainingDirectory().GetGitPathString().IsEmpty())
1326                                                 ignorePattern += _T("/") + path[i].GetContainingDirectory().GetGitPathString();
1327
1328                                         ignorePattern += _T("/");
1329                                 }
1330                                 if (IsMask)
1331                                 {
1332                                         ignorePattern += _T("*") + path[i].GetFileExtension();
1333                                 }
1334                                 else
1335                                 {
1336                                         ignorePattern += path[i].GetFileOrDirectoryName();
1337                                 }
1338
1339                                 // escape [ and ] so that files get ignored correctly
1340                                 ignorePattern.Replace(_T("["), _T("\\["));
1341                                 ignorePattern.Replace(_T("]"), _T("\\]"));
1342
1343                                 ignorePattern += _T("\n");
1344                                 CStringA ignorePatternA = CUnicodeUtils::GetUTF8(ignorePattern);
1345                                 file.Write(ignorePatternA.GetBuffer(), ignorePatternA.GetLength());
1346                                 ignorePatternA.ReleaseBuffer();
1347
1348                                 if (ignoreDlg.m_IgnoreFile == 1)
1349                                         file.Close();
1350                         }
1351
1352                         if (ignoreDlg.m_IgnoreFile != 1)
1353                                 file.Close();
1354                 }
1355                 catch(...)
1356                 {
1357                         file.Abort();
1358                         return false;
1359                 }
1360
1361                 return true;
1362         }
1363         return false;
1364 }
1365
1366
1367 bool CAppUtils::GitReset(CString *CommitHash,int type)
1368 {
1369         CResetDlg dlg;
1370         dlg.m_ResetType=type;
1371         dlg.m_ResetToVersion=*CommitHash;
1372         dlg.m_initialRefName = *CommitHash;
1373         if (dlg.DoModal() == IDOK)
1374         {
1375                 CString cmd;
1376                 CString type;
1377                 switch(dlg.m_ResetType)
1378                 {
1379                 case 0:
1380                         type=_T("--soft");
1381                         break;
1382                 case 1:
1383                         type=_T("--mixed");
1384                         break;
1385                 case 2:
1386                         type=_T("--hard");
1387                         break;
1388                 default:
1389                         type=_T("--mixed");
1390                         break;
1391                 }
1392                 cmd.Format(_T("git.exe reset %s %s"),type, dlg.m_ResetToVersion);
1393
1394                 while (true)
1395                 {
1396                         CProgressDlg progress;
1397                         progress.m_GitCmd=cmd;
1398
1399                         CTGitPath gitPath = g_Git.m_CurrentDir;
1400                         if (gitPath.HasSubmodules() && dlg.m_ResetType == 2)
1401                                 progress.m_PostCmdList.Add(CString(MAKEINTRESOURCE(IDS_PROC_SUBMODULESUPDATE)));
1402
1403                         progress.m_PostFailCmdList.Add(CString(MAKEINTRESOURCE(IDS_MSGBOX_RETRY)));
1404
1405                         INT_PTR ret = progress.DoModal();
1406                         if (progress.m_GitStatus == 0 && gitPath.HasSubmodules() && dlg.m_ResetType == 2 && ret == IDC_PROGRESS_BUTTON1)
1407                         {
1408                                 CString sCmd;
1409                                 sCmd.Format(_T("/command:subupdate /bkpath:\"%s\""), g_Git.m_CurrentDir);
1410
1411                                 RunTortoiseGitProc(sCmd);
1412                                 return TRUE;
1413                         }
1414                         else if (progress.m_GitStatus != 0 && ret == IDC_PROGRESS_BUTTON1)
1415                                 continue;       // retry
1416                         else if (ret == IDOK)
1417                                 return TRUE;
1418                         else
1419                                 break;
1420                 }
1421         }
1422         return FALSE;
1423 }
1424
1425 void CAppUtils::DescribeFile(bool mode, bool base,CString &descript)
1426 {
1427         if(mode == FALSE)
1428         {
1429                 descript = CString(MAKEINTRESOURCE(IDS_SVNACTION_DELETE));
1430                 return;
1431         }
1432         if(base)
1433         {
1434                 descript = CString(MAKEINTRESOURCE(IDS_SVNACTION_MODIFIED));
1435                 return;
1436         }
1437         descript = CString(MAKEINTRESOURCE(IDS_PROC_CREATED));
1438         return;
1439 }
1440
1441 void CAppUtils::RemoveTempMergeFile(CTGitPath &path)
1442 {
1443                 CString tempmergefile;
1444                 try
1445                 {
1446                         tempmergefile = CAppUtils::GetMergeTempFile(_T("LOCAL"),path);
1447                         CFile::Remove(tempmergefile);
1448                 }catch(...)
1449                 {
1450                 }
1451
1452                 try
1453                 {
1454                         tempmergefile = CAppUtils::GetMergeTempFile(_T("REMOTE"),path);
1455                         CFile::Remove(tempmergefile);
1456                 }catch(...)
1457                 {
1458                 }
1459
1460                 try
1461                 {
1462                         tempmergefile = CAppUtils::GetMergeTempFile(_T("BASE"),path);
1463                         CFile::Remove(tempmergefile);
1464                 }catch(...)
1465                 {
1466                 }
1467 }
1468 CString CAppUtils::GetMergeTempFile(CString type,CTGitPath &merge)
1469 {
1470         CString file;
1471         file=g_Git.m_CurrentDir+_T("\\") + merge.GetWinPathString()+_T(".")+type+merge.GetFileExtension();
1472
1473         return file;
1474 }
1475
1476 bool ParseHashesFromLsFile(BYTE_VECTOR &out, CString &hash1, CString &hash2, CString &hash3)
1477 {
1478         unsigned int pos = 0;
1479         CString one;
1480         CString part;
1481
1482         while (pos >= 0 && pos < out.size())
1483         {
1484                 one.Empty();
1485
1486                 g_Git.StringAppend(&one, &out[pos], CP_UTF8);
1487                 int tabstart = 0;
1488                 one.Tokenize(_T("\t"), tabstart);
1489
1490                 tabstart = 0;
1491                 part = one.Tokenize(_T(" "), tabstart); //Tag
1492                 part = one.Tokenize(_T(" "), tabstart); //Mode
1493                 part = one.Tokenize(_T(" "), tabstart); //Hash
1494                 CString hash = part;
1495                 part = one.Tokenize(_T("\t"), tabstart); //Stage
1496                 int stage = _ttol(part);
1497                 if (stage == 1)
1498                         hash1 = hash;
1499                 else if (stage == 2)
1500                         hash2 = hash;
1501                 else if (stage == 3)
1502                 {
1503                         hash3 = hash;
1504                         return true;
1505                 }
1506
1507                 pos = out.findNextString(pos);
1508         }
1509
1510         return false;
1511 }
1512
1513 bool CAppUtils::ConflictEdit(CTGitPath &path,bool /*bAlternativeTool*/,bool revertTheirMy)
1514 {
1515         bool bRet = false;
1516
1517         CTGitPath merge=path;
1518         CTGitPath directory = merge.GetDirectory();
1519
1520         // we have the conflicted file (%merged)
1521         // now look for the other required files
1522         //GitStatus stat;
1523         //stat.GetStatus(merge);
1524         //if (stat.status == NULL)
1525         //      return false;
1526
1527         BYTE_VECTOR vector;
1528
1529         CString cmd;
1530         cmd.Format(_T("git.exe ls-files -u -t -z -- \"%s\""),merge.GetGitPathString());
1531
1532         if (g_Git.Run(cmd, &vector))
1533         {
1534                 return FALSE;
1535         }
1536
1537         if (merge.IsDirectory())
1538         {
1539                 CString baseHash, localHash, remoteHash;
1540                 if (!ParseHashesFromLsFile(vector, baseHash, localHash, remoteHash))
1541                         return FALSE;
1542
1543                 CString msg;
1544                 msg.Format(_T("BASE: %s\nLOCAL: %s\nREMOTE: %s"), baseHash, localHash, remoteHash);
1545                 CMessageBox::Show(NULL, msg, _T("TortoiseGit"), MB_OK);
1546                 return TRUE;
1547         }
1548
1549         CTGitPathList list;
1550         list.ParserFromLsFile(vector);
1551
1552         if(list.GetCount() == 0)
1553                 return FALSE;
1554
1555         CTGitPath theirs;
1556         CTGitPath mine;
1557         CTGitPath base;
1558
1559         if (revertTheirMy)
1560         {
1561                 mine.SetFromGit(GetMergeTempFile(_T("REMOTE"), merge));
1562                 theirs.SetFromGit(GetMergeTempFile(_T("LOCAL"), merge));
1563         }
1564         else
1565         {
1566                 mine.SetFromGit(GetMergeTempFile(_T("LOCAL"), merge));
1567                 theirs.SetFromGit(GetMergeTempFile(_T("REMOTE"), merge));
1568         }
1569         base.SetFromGit(GetMergeTempFile(_T("BASE"),merge));
1570
1571         CString format;
1572
1573         //format=_T("git.exe cat-file blob \":%d:%s\"");
1574         format = _T("git checkout-index --temp --stage=%d -- \"%s\"");
1575         CFile tempfile;
1576         //create a empty file, incase stage is not three
1577         tempfile.Open(mine.GetWinPathString(),CFile::modeCreate|CFile::modeReadWrite);
1578         tempfile.Close();
1579         tempfile.Open(theirs.GetWinPathString(),CFile::modeCreate|CFile::modeReadWrite);
1580         tempfile.Close();
1581         tempfile.Open(base.GetWinPathString(),CFile::modeCreate|CFile::modeReadWrite);
1582         tempfile.Close();
1583
1584         bool b_base=false, b_local=false, b_remote=false;
1585
1586         for (int i = 0; i< list.GetCount(); ++i)
1587         {
1588                 CString cmd;
1589                 CString outfile;
1590                 cmd.Empty();
1591                 outfile.Empty();
1592
1593                 if( list[i].m_Stage == 1)
1594                 {
1595                         cmd.Format(format, list[i].m_Stage, list[i].GetGitPathString());
1596                         b_base = true;
1597                         outfile = base.GetWinPathString();
1598
1599                 }
1600                 if( list[i].m_Stage == 2 )
1601                 {
1602                         cmd.Format(format, list[i].m_Stage, list[i].GetGitPathString());
1603                         b_local = true;
1604                         outfile = mine.GetWinPathString();
1605
1606                 }
1607                 if( list[i].m_Stage == 3 )
1608                 {
1609                         cmd.Format(format, list[i].m_Stage, list[i].GetGitPathString());
1610                         b_remote = true;
1611                         outfile = theirs.GetWinPathString();
1612                 }
1613                 CString output, err;
1614                 if(!outfile.IsEmpty())
1615                         if (!g_Git.Run(cmd, &output, &err, CP_UTF8))
1616                         {
1617                                 CString file;
1618                                 int start =0 ;
1619                                 file = output.Tokenize(_T("\t"), start);
1620                                 ::MoveFileEx(file,outfile,MOVEFILE_REPLACE_EXISTING|MOVEFILE_COPY_ALLOWED);
1621                         }
1622                         else
1623                         {
1624                                 CMessageBox::Show(NULL, output + L"\n" + err, _T("TortoiseGit"), MB_OK|MB_ICONERROR);
1625                         }
1626         }
1627
1628         if(b_local && b_remote )
1629         {
1630                 merge.SetFromWin(g_Git.m_CurrentDir+_T("\\")+merge.GetWinPathString());
1631                 if( revertTheirMy )
1632                         bRet = !!CAppUtils::StartExtMerge(base, mine, theirs, merge, _T("BASE"), _T("REMOTE"), _T("LOCAL"));
1633                 else
1634                         bRet = !!CAppUtils::StartExtMerge(base, theirs, mine, merge,_T("BASE"), _T("REMOTE"), _T("LOCAL"));
1635
1636         }
1637         else
1638         {
1639                 CFile::Remove(mine.GetWinPathString());
1640                 CFile::Remove(theirs.GetWinPathString());
1641                 CFile::Remove(base.GetWinPathString());
1642
1643                 CDeleteConflictDlg dlg;
1644                 DescribeFile(b_local, b_base,dlg.m_LocalStatus);
1645                 DescribeFile(b_remote,b_base,dlg.m_RemoteStatus);
1646                 dlg.m_bShowModifiedButton=b_base;
1647                 dlg.m_File=merge.GetGitPathString();
1648                 if(dlg.DoModal() == IDOK)
1649                 {
1650                         CString cmd,out;
1651                         if(dlg.m_bIsDelete)
1652                         {
1653                                 cmd.Format(_T("git.exe rm -- \"%s\""),merge.GetGitPathString());
1654                         }
1655                         else
1656                                 cmd.Format(_T("git.exe add -- \"%s\""),merge.GetGitPathString());
1657
1658                         if (g_Git.Run(cmd, &out, CP_UTF8))
1659                         {
1660                                 CMessageBox::Show(NULL,out,_T("TortoiseGit"),MB_OK);
1661                                 return FALSE;
1662                         }
1663                         return TRUE;
1664                 }
1665                 else
1666                         return FALSE;
1667         }
1668
1669 #if 0
1670         CAppUtils::StartExtMerge(CAppUtils::MergeFlags().AlternativeTool(bAlternativeTool),
1671                         base, theirs, mine, merge);
1672 #endif
1673 #if 0
1674         if (stat.status->text_status == svn_wc_status_conflicted)
1675         {
1676                 // we have a text conflict, use our merge tool to resolve the conflict
1677
1678                 CTSVNPath theirs(directory);
1679                 CTSVNPath mine(directory);
1680                 CTSVNPath base(directory);
1681                 bool bConflictData = false;
1682
1683                 if ((stat.status->entry)&&(stat.status->entry->conflict_new))
1684                 {
1685                         theirs.AppendPathString(CUnicodeUtils::GetUnicode(stat.status->entry->conflict_new));
1686                         bConflictData = true;
1687                 }
1688                 if ((stat.status->entry)&&(stat.status->entry->conflict_old))
1689                 {
1690                         base.AppendPathString(CUnicodeUtils::GetUnicode(stat.status->entry->conflict_old));
1691                         bConflictData = true;
1692                 }
1693                 if ((stat.status->entry)&&(stat.status->entry->conflict_wrk))
1694                 {
1695                         mine.AppendPathString(CUnicodeUtils::GetUnicode(stat.status->entry->conflict_wrk));
1696                         bConflictData = true;
1697                 }
1698                 else
1699                 {
1700                         mine = merge;
1701                 }
1702                 if (bConflictData)
1703                         bRet = !!CAppUtils::StartExtMerge(CAppUtils::MergeFlags().AlternativeTool(bAlternativeTool),
1704                                                                                                 base, theirs, mine, merge);
1705         }
1706
1707         if (stat.status->prop_status == svn_wc_status_conflicted)
1708         {
1709                 // we have a property conflict
1710                 CTSVNPath prej(directory);
1711                 if ((stat.status->entry)&&(stat.status->entry->prejfile))
1712                 {
1713                         prej.AppendPathString(CUnicodeUtils::GetUnicode(stat.status->entry->prejfile));
1714                         // there's a problem: the prej file contains a _description_ of the conflict, and
1715                         // that description string might be translated. That means we have no way of parsing
1716                         // the file to find out the conflicting values.
1717                         // The only thing we can do: show a dialog with the conflict description, then
1718                         // let the user either accept the existing property or open the property edit dialog
1719                         // to manually change the properties and values. And a button to mark the conflict as
1720                         // resolved.
1721                         CEditPropConflictDlg dlg;
1722                         dlg.SetPrejFile(prej);
1723                         dlg.SetConflictedItem(merge);
1724                         bRet = (dlg.DoModal() != IDCANCEL);
1725                 }
1726         }
1727
1728         if (stat.status->tree_conflict)
1729         {
1730                 // we have a tree conflict
1731                 SVNInfo info;
1732                 const SVNInfoData * pInfoData = info.GetFirstFileInfo(merge, SVNRev(), SVNRev());
1733                 if (pInfoData)
1734                 {
1735                         if (pInfoData->treeconflict_kind == svn_wc_conflict_kind_text)
1736                         {
1737                                 CTSVNPath theirs(directory);
1738                                 CTSVNPath mine(directory);
1739                                 CTSVNPath base(directory);
1740                                 bool bConflictData = false;
1741
1742                                 if (pInfoData->treeconflict_theirfile)
1743                                 {
1744                                         theirs.AppendPathString(pInfoData->treeconflict_theirfile);
1745                                         bConflictData = true;
1746                                 }
1747                                 if (pInfoData->treeconflict_basefile)
1748                                 {
1749                                         base.AppendPathString(pInfoData->treeconflict_basefile);
1750                                         bConflictData = true;
1751                                 }
1752                                 if (pInfoData->treeconflict_myfile)
1753                                 {
1754                                         mine.AppendPathString(pInfoData->treeconflict_myfile);
1755                                         bConflictData = true;
1756                                 }
1757                                 else
1758                                 {
1759                                         mine = merge;
1760                                 }
1761                                 if (bConflictData)
1762                                         bRet = !!CAppUtils::StartExtMerge(CAppUtils::MergeFlags().AlternativeTool(bAlternativeTool),
1763                                                                                                                 base, theirs, mine, merge);
1764                         }
1765                         else if (pInfoData->treeconflict_kind == svn_wc_conflict_kind_tree)
1766                         {
1767                                 CString sConflictAction;
1768                                 CString sConflictReason;
1769                                 CString sResolveTheirs;
1770                                 CString sResolveMine;
1771                                 CTSVNPath treeConflictPath = CTSVNPath(pInfoData->treeconflict_path);
1772                                 CString sItemName = treeConflictPath.GetUIFileOrDirectoryName();
1773
1774                                 if (pInfoData->treeconflict_nodekind == svn_node_file)
1775                                 {
1776                                         switch (pInfoData->treeconflict_operation)
1777                                         {
1778                                         case svn_wc_operation_update:
1779                                                 switch (pInfoData->treeconflict_action)
1780                                                 {
1781                                                 case svn_wc_conflict_action_edit:
1782                                                         sConflictAction.Format(IDS_TREECONFLICT_FILEUPDATEEDIT, (LPCTSTR)sItemName);
1783                                                         sResolveTheirs.LoadString(IDS_TREECONFLICT_RESOLVE_KEEPREPOSITORYFILE);
1784                                                         break;
1785                                                 case svn_wc_conflict_action_add:
1786                                                         sConflictAction.Format(IDS_TREECONFLICT_FILEUPDATEADD, (LPCTSTR)sItemName);
1787                                                         sResolveTheirs.LoadString(IDS_TREECONFLICT_RESOLVE_KEEPREPOSITORYFILE);
1788                                                         break;
1789                                                 case svn_wc_conflict_action_delete:
1790                                                         sConflictAction.Format(IDS_TREECONFLICT_FILEUPDATEDELETE, (LPCTSTR)sItemName);
1791                                                         sResolveTheirs.LoadString(IDS_TREECONFLICT_RESOLVE_REMOVEFILE);
1792                                                         break;
1793                                                 }
1794                                                 break;
1795                                         case svn_wc_operation_switch:
1796                                                 switch (pInfoData->treeconflict_action)
1797                                                 {
1798                                                 case svn_wc_conflict_action_edit:
1799                                                         sConflictAction.Format(IDS_TREECONFLICT_FILESWITCHEDIT, (LPCTSTR)sItemName);
1800                                                         sResolveTheirs.LoadString(IDS_TREECONFLICT_RESOLVE_KEEPREPOSITORYFILE);
1801                                                         break;
1802                                                 case svn_wc_conflict_action_add:
1803                                                         sConflictAction.Format(IDS_TREECONFLICT_FILESWITCHADD, (LPCTSTR)sItemName);
1804                                                         sResolveTheirs.LoadString(IDS_TREECONFLICT_RESOLVE_KEEPREPOSITORYFILE);
1805                                                         break;
1806                                                 case svn_wc_conflict_action_delete:
1807                                                         sConflictAction.Format(IDS_TREECONFLICT_FILESWITCHDELETE, (LPCTSTR)sItemName);
1808                                                         sResolveTheirs.LoadString(IDS_TREECONFLICT_RESOLVE_REMOVEFILE);
1809                                                         break;
1810                                                 }
1811                                                 break;
1812                                         case svn_wc_operation_merge:
1813                                                 switch (pInfoData->treeconflict_action)
1814                                                 {
1815                                                 case svn_wc_conflict_action_edit:
1816                                                         sConflictAction.Format(IDS_TREECONFLICT_FILEMERGEEDIT, (LPCTSTR)sItemName);
1817                                                         sResolveTheirs.LoadString(IDS_TREECONFLICT_RESOLVE_KEEPREPOSITORYFILE);
1818                                                         break;
1819                                                 case svn_wc_conflict_action_add:
1820                                                         sResolveTheirs.Format(IDS_TREECONFLICT_FILEMERGEADD, (LPCTSTR)sItemName);
1821                                                         sResolveTheirs.LoadString(IDS_TREECONFLICT_RESOLVE_KEEPREPOSITORYFILE);
1822                                                         break;
1823                                                 case svn_wc_conflict_action_delete:
1824                                                         sConflictAction.Format(IDS_TREECONFLICT_FILEMERGEDELETE, (LPCTSTR)sItemName);
1825                                                         sResolveTheirs.LoadString(IDS_TREECONFLICT_RESOLVE_REMOVEFILE);
1826                                                         break;
1827                                                 }
1828                                                 break;
1829                                         }
1830                                 }
1831                                 else if (pInfoData->treeconflict_nodekind == svn_node_dir)
1832                                 {
1833                                         switch (pInfoData->treeconflict_operation)
1834                                         {
1835                                         case svn_wc_operation_update:
1836                                                 switch (pInfoData->treeconflict_action)
1837                                                 {
1838                                                 case svn_wc_conflict_action_edit:
1839                                                         sConflictAction.Format(IDS_TREECONFLICT_DIRUPDATEEDIT, (LPCTSTR)sItemName);
1840                                                         sResolveTheirs.LoadString(IDS_TREECONFLICT_RESOLVE_KEEPREPOSITORYDIR);
1841                                                         break;
1842                                                 case svn_wc_conflict_action_add:
1843                                                         sConflictAction.Format(IDS_TREECONFLICT_DIRUPDATEADD, (LPCTSTR)sItemName);
1844                                                         sResolveTheirs.LoadString(IDS_TREECONFLICT_RESOLVE_KEEPREPOSITORYDIR);
1845                                                         break;
1846                                                 case svn_wc_conflict_action_delete:
1847                                                         sConflictAction.Format(IDS_TREECONFLICT_DIRUPDATEDELETE, (LPCTSTR)sItemName);
1848                                                         sResolveTheirs.LoadString(IDS_TREECONFLICT_RESOLVE_REMOVEDIR);
1849                                                         break;
1850                                                 }
1851                                                 break;
1852                                         case svn_wc_operation_switch:
1853                                                 switch (pInfoData->treeconflict_action)
1854                                                 {
1855                                                 case svn_wc_conflict_action_edit:
1856                                                         sConflictAction.Format(IDS_TREECONFLICT_DIRSWITCHEDIT, (LPCTSTR)sItemName);
1857                                                         sResolveTheirs.LoadString(IDS_TREECONFLICT_RESOLVE_KEEPREPOSITORYDIR);
1858                                                         break;
1859                                                 case svn_wc_conflict_action_add:
1860                                                         sConflictAction.Format(IDS_TREECONFLICT_DIRSWITCHADD, (LPCTSTR)sItemName);
1861                                                         sResolveTheirs.LoadString(IDS_TREECONFLICT_RESOLVE_KEEPREPOSITORYDIR);
1862                                                         break;
1863                                                 case svn_wc_conflict_action_delete:
1864                                                         sConflictAction.Format(IDS_TREECONFLICT_DIRSWITCHDELETE, (LPCTSTR)sItemName);
1865                                                         sResolveTheirs.LoadString(IDS_TREECONFLICT_RESOLVE_REMOVEDIR);
1866                                                         break;
1867                                                 }
1868                                                 break;
1869                                         case svn_wc_operation_merge:
1870                                                 switch (pInfoData->treeconflict_action)
1871                                                 {
1872                                                 case svn_wc_conflict_action_edit:
1873                                                         sConflictAction.Format(IDS_TREECONFLICT_DIRMERGEEDIT, (LPCTSTR)sItemName);
1874                                                         sResolveTheirs.LoadString(IDS_TREECONFLICT_RESOLVE_KEEPREPOSITORYDIR);
1875                                                         break;
1876                                                 case svn_wc_conflict_action_add:
1877                                                         sConflictAction.Format(IDS_TREECONFLICT_DIRMERGEADD, (LPCTSTR)sItemName);
1878                                                         sResolveTheirs.LoadString(IDS_TREECONFLICT_RESOLVE_KEEPREPOSITORYDIR);
1879                                                         break;
1880                                                 case svn_wc_conflict_action_delete:
1881                                                         sConflictAction.Format(IDS_TREECONFLICT_DIRMERGEDELETE, (LPCTSTR)sItemName);
1882                                                         sResolveTheirs.LoadString(IDS_TREECONFLICT_RESOLVE_REMOVEDIR);
1883                                                         break;
1884                                                 }
1885                                                 break;
1886                                         }
1887                                 }
1888
1889                                 UINT uReasonID = 0;
1890                                 switch (pInfoData->treeconflict_reason)
1891                                 {
1892                                 case svn_wc_conflict_reason_edited:
1893                                         uReasonID = IDS_TREECONFLICT_REASON_EDITED;
1894                                         sResolveMine.LoadString(pInfoData->treeconflict_nodekind == svn_node_dir ? IDS_TREECONFLICT_RESOLVE_KEEPLOCALDIR : IDS_TREECONFLICT_RESOLVE_KEEPLOCALFILE);
1895                                         break;
1896                                 case svn_wc_conflict_reason_obstructed:
1897                                         uReasonID = IDS_TREECONFLICT_REASON_OBSTRUCTED;
1898                                         sResolveMine.LoadString(pInfoData->treeconflict_nodekind == svn_node_dir ? IDS_TREECONFLICT_RESOLVE_KEEPLOCALDIR : IDS_TREECONFLICT_RESOLVE_KEEPLOCALFILE);
1899                                         break;
1900                                 case svn_wc_conflict_reason_deleted:
1901                                         uReasonID = IDS_TREECONFLICT_REASON_DELETED;
1902                                         sResolveMine.LoadString(pInfoData->treeconflict_nodekind == svn_node_dir ? IDS_TREECONFLICT_RESOLVE_REMOVEDIR : IDS_TREECONFLICT_RESOLVE_REMOVEFILE);
1903                                         break;
1904                                 case svn_wc_conflict_reason_added:
1905                                         uReasonID = IDS_TREECONFLICT_REASON_ADDED;
1906                                         sResolveMine.LoadString(pInfoData->treeconflict_nodekind == svn_node_dir ? IDS_TREECONFLICT_RESOLVE_KEEPLOCALDIR : IDS_TREECONFLICT_RESOLVE_KEEPLOCALFILE);
1907                                         break;
1908                                 case svn_wc_conflict_reason_missing:
1909                                         uReasonID = IDS_TREECONFLICT_REASON_MISSING;
1910                                         sResolveMine.LoadString(pInfoData->treeconflict_nodekind == svn_node_dir ? IDS_TREECONFLICT_RESOLVE_REMOVEDIR : IDS_TREECONFLICT_RESOLVE_REMOVEFILE);
1911                                         break;
1912                                 case svn_wc_conflict_reason_unversioned:
1913                                         uReasonID = IDS_TREECONFLICT_REASON_UNVERSIONED;
1914                                         sResolveMine.LoadString(pInfoData->treeconflict_nodekind == svn_node_dir ? IDS_TREECONFLICT_RESOLVE_KEEPLOCALDIR : IDS_TREECONFLICT_RESOLVE_KEEPLOCALFILE);
1915                                         break;
1916                                 }
1917                                 sConflictReason.Format(uReasonID, (LPCTSTR)sConflictAction);
1918
1919                                 CTreeConflictEditorDlg dlg;
1920                                 dlg.SetConflictInfoText(sConflictReason);
1921                                 dlg.SetResolveTexts(sResolveTheirs, sResolveMine);
1922                                 dlg.SetPath(treeConflictPath);
1923                                 INT_PTR dlgRet = dlg.DoModal();
1924                                 bRet = (dlgRet != IDCANCEL);
1925                         }
1926                 }
1927         }
1928 #endif
1929         return bRet;
1930 }
1931
1932 bool CAppUtils::IsSSHPutty()
1933 {
1934         CString sshclient=g_Git.m_Environment.GetEnv(_T("GIT_SSH"));
1935         sshclient=sshclient.MakeLower();
1936         if(sshclient.Find(_T("plink.exe"),0)>=0)
1937         {
1938                 return true;
1939         }
1940         return false;
1941 }
1942
1943 CString CAppUtils::GetClipboardLink()
1944 {
1945         if (!OpenClipboard(NULL))
1946                 return CString();
1947
1948         CString sClipboardText;
1949         HGLOBAL hglb = GetClipboardData(CF_TEXT);
1950         if (hglb)
1951         {
1952                 LPCSTR lpstr = (LPCSTR)GlobalLock(hglb);
1953                 sClipboardText = CString(lpstr);
1954                 GlobalUnlock(hglb);
1955         }
1956         hglb = GetClipboardData(CF_UNICODETEXT);
1957         if (hglb)
1958         {
1959                 LPCTSTR lpstr = (LPCTSTR)GlobalLock(hglb);
1960                 sClipboardText = lpstr;
1961                 GlobalUnlock(hglb);
1962         }
1963         CloseClipboard();
1964
1965         if(!sClipboardText.IsEmpty())
1966         {
1967                 if(sClipboardText[0] == _T('\"') && sClipboardText[sClipboardText.GetLength()-1] == _T('\"'))
1968                         sClipboardText=sClipboardText.Mid(1,sClipboardText.GetLength()-2);
1969
1970                 if(sClipboardText.Find( _T("http://")) == 0)
1971                         return sClipboardText;
1972
1973                 if(sClipboardText.Find( _T("https://")) == 0)
1974                         return sClipboardText;
1975
1976                 if(sClipboardText.Find( _T("git://")) == 0)
1977                         return sClipboardText;
1978
1979                 if(sClipboardText.Find( _T("ssh://")) == 0)
1980                         return sClipboardText;
1981
1982                 if(sClipboardText.GetLength()>=2)
1983                         if( sClipboardText[1] == _T(':') )
1984                                 if( (sClipboardText[0] >= 'A' &&  sClipboardText[0] <= 'Z')
1985                                         || (sClipboardText[0] >= 'a' &&  sClipboardText[0] <= 'z') )
1986                                         return sClipboardText;
1987         }
1988
1989         return CString(_T(""));
1990 }
1991
1992 CString CAppUtils::ChooseRepository(CString *path)
1993 {
1994         CBrowseFolder browseFolder;
1995         CRegString  regLastResopitory = CRegString(_T("Software\\TortoiseGit\\TortoiseProc\\LastRepo"),_T(""));
1996
1997         browseFolder.m_style = BIF_EDITBOX | BIF_NEWDIALOGSTYLE | BIF_RETURNFSANCESTORS | BIF_RETURNONLYFSDIRS;
1998         CString strCloneDirectory;
1999         if(path)
2000                 strCloneDirectory=*path;
2001         else
2002         {
2003                 strCloneDirectory = regLastResopitory;
2004         }
2005
2006         CString title;
2007         title.LoadString(IDS_CHOOSE_REPOSITORY);
2008
2009         browseFolder.SetInfo(title);
2010
2011         if (browseFolder.Show(NULL, strCloneDirectory) == CBrowseFolder::OK)
2012         {
2013                 regLastResopitory = strCloneDirectory;
2014                 return strCloneDirectory;
2015         }
2016         else
2017         {
2018                 return CString();
2019         }
2020 }
2021
2022 bool CAppUtils::SendPatchMail(CTGitPathList &list,bool autoclose)
2023 {
2024         CSendMailDlg dlg;
2025
2026         dlg.m_PathList  = list;
2027
2028         if(dlg.DoModal()==IDOK)
2029         {
2030                 if(dlg.m_PathList.GetCount() == 0)
2031                         return FALSE;
2032
2033                 CGitProgressDlg progDlg;
2034
2035                 theApp.m_pMainWnd = &progDlg;
2036                 progDlg.SetCommand(CGitProgressList::GitProgress_SendMail);
2037
2038                 progDlg.SetAutoClose(autoclose);
2039
2040                 progDlg.SetPathList(dlg.m_PathList);
2041                                 //ProjectProperties props;
2042                                 //props.ReadPropsPathList(dlg.m_pathList);
2043                                 //progDlg.SetProjectProperties(props);
2044                 progDlg.SetItemCount(dlg.m_PathList.GetCount());
2045
2046                 CSendMailPatch sendMailPatch(dlg.m_To, dlg.m_CC, dlg.m_Subject, !!dlg.m_bAttachment, !!dlg.m_bCombine, !!dlg.m_bUseMAPI);
2047                 progDlg.SetSendMailOption(&sendMailPatch);
2048
2049                 progDlg.DoModal();
2050
2051                 return true;
2052         }
2053         return false;
2054 }
2055
2056 bool CAppUtils::SendPatchMail(CString &cmd,CString &formatpatchoutput,bool autoclose)
2057 {
2058         CTGitPathList list;
2059         CString log=formatpatchoutput;
2060         int start=log.Find(cmd);
2061         if(start >=0)
2062                 CString one=log.Tokenize(_T("\n"),start);
2063         else
2064                 start = 0;
2065
2066         while(start>=0)
2067         {
2068                 CString one=log.Tokenize(_T("\n"),start);
2069                 one=one.Trim();
2070                 if(one.IsEmpty() || one.Find(_T("Success")) == 0)
2071                         continue;
2072                 one.Replace(_T('/'),_T('\\'));
2073                 CTGitPath path;
2074                 path.SetFromWin(one);
2075                 list.AddPath(path);
2076         }
2077         if (list.GetCount() > 0)
2078         {
2079                 return SendPatchMail(list, autoclose);
2080         }
2081         else
2082         {
2083                 CMessageBox::Show(NULL, IDS_ERR_NOPATCHES, IDS_APPNAME, MB_ICONINFORMATION);
2084                 return true;
2085         }
2086 }
2087
2088
2089 int CAppUtils::GetLogOutputEncode(CGit *pGit)
2090 {
2091         CString cmd,output;
2092         int start=0;
2093
2094         output = pGit->GetConfigValue(_T("i18n.logOutputEncoding"));
2095         if(output.IsEmpty())
2096         {
2097                 output =  pGit->GetConfigValue(_T("i18n.commitencoding"));
2098                 if(output.IsEmpty())
2099                         return CP_UTF8;
2100
2101                 int start=0;
2102                 output=output.Tokenize(_T("\n"),start);
2103                 return CUnicodeUtils::GetCPCode(output);
2104
2105         }
2106         else
2107         {
2108                 output=output.Tokenize(_T("\n"),start);
2109                 return CUnicodeUtils::GetCPCode(output);
2110         }
2111 }
2112 int CAppUtils::GetCommitTemplate(CString &temp)
2113 {
2114         CString cmd,output;
2115
2116         output = g_Git.GetConfigValue(_T("commit.template"), CP_UTF8);
2117         if( output.IsEmpty() )
2118                 return -1;
2119
2120         if( output.GetLength()<1)
2121                 return -1;
2122
2123         if( output[0] == _T('/'))
2124         {
2125                 if(output.GetLength()>=3)
2126                         if(output[2] == _T('/'))
2127                         {
2128                                 output.GetBuffer()[0] = output[1];
2129                                 output.GetBuffer()[1] = _T(':');
2130                         }
2131         }
2132
2133         int start=0;
2134         output=output.Tokenize(_T("\n"),start);
2135
2136         output.Replace(_T('/'),_T('\\'));
2137
2138         try
2139         {
2140                 CStdioFile file(output,CFile::modeRead|CFile::typeText);
2141                 CString str;
2142                 while(file.ReadString(str))
2143                 {
2144                         temp+=str+_T("\n");
2145                 }
2146
2147         }catch(...)
2148         {
2149                 return -1;
2150         }
2151         return 0;
2152 }
2153 int CAppUtils::SaveCommitUnicodeFile(CString &filename, CString &message)
2154 {
2155         CFile file(filename,CFile::modeReadWrite|CFile::modeCreate );
2156         CString cmd,output;
2157         int cp=CP_UTF8;
2158
2159         output= g_Git.GetConfigValue(_T("i18n.commitencoding"));
2160         if(output.IsEmpty())
2161                 cp=CP_UTF8;
2162
2163         int start=0;
2164         output=output.Tokenize(_T("\n"),start);
2165         cp=CUnicodeUtils::GetCPCode(output);
2166
2167         int len=message.GetLength();
2168
2169         std::unique_ptr<char[]> buf(new char[len * 4 + 4]);
2170         SecureZeroMemory(buf.get(), len * 4 + 4);
2171
2172         int lengthIncTerminator = WideCharToMultiByte(cp, 0, message, -1, buf.get(), len * 4, NULL, NULL);
2173
2174         file.Write(buf.get(), lengthIncTerminator - 1);
2175         file.Close();
2176         return 0;
2177 }
2178
2179 bool CAppUtils::Fetch(CString remoteName, bool allowRebase, bool autoClose)
2180 {
2181         CPullFetchDlg dlg;
2182         dlg.m_PreSelectRemote = remoteName;
2183         dlg.m_bAllowRebase = allowRebase;
2184         dlg.m_IsPull=FALSE;
2185
2186         if(dlg.DoModal()==IDOK)
2187         {
2188                 if(dlg.m_bAutoLoad)
2189                 {
2190                         if (dlg.m_bAllRemotes)
2191                         {
2192                                 STRING_VECTOR list;
2193                                 g_Git.GetRemoteList(list);
2194
2195                                 STRING_VECTOR::const_iterator it = list.begin();
2196                                 while (it != list.end())
2197                                 {
2198                                         CString remote(*it);
2199                                         CAppUtils::LaunchPAgent(NULL, &remote);
2200                                         ++it;
2201                                 }
2202                         }
2203                         else
2204                                 CAppUtils::LaunchPAgent(NULL, &dlg.m_RemoteURL);
2205                 }
2206
2207                 CString url;
2208                 url=dlg.m_RemoteURL;
2209                 CString cmd;
2210                 CString arg;
2211
2212                 int ver = CAppUtils::GetMsysgitVersion();
2213
2214                 if(ver >= 0x01070203) //above 1.7.0.2
2215                         arg = _T("--progress ");
2216
2217                 if (dlg.m_bPrune) {
2218                         arg += _T("--prune ");
2219                 }
2220
2221                 if (dlg.m_bFetchTags == 1)
2222                 {
2223                         arg += _T("--tags ");
2224                 }
2225                 else if (dlg.m_bFetchTags == 0)
2226                 {
2227                         arg += _T("--no-tags ");
2228                 }
2229
2230                 if (dlg.m_bAllRemotes)
2231                         cmd.Format(_T("git.exe fetch --all -v %s"), arg);
2232                 else
2233                         cmd.Format(_T("git.exe fetch -v %s \"%s\" %s"), arg, url, dlg.m_RemoteBranchName);
2234
2235                 CProgressDlg progress;
2236
2237                 progress.m_bAutoCloseOnSuccess = autoClose;
2238
2239                 progress.m_PostCmdList.Add(CString(MAKEINTRESOURCE(IDS_MENULOG)));
2240                 progress.m_PostCmdList.Add(CString(MAKEINTRESOURCE(IDS_PROC_RESET)));
2241
2242                 if(!dlg.m_bRebase && !g_GitAdminDir.IsBareRepo(g_Git.m_CurrentDir))
2243                 {
2244                         progress.m_PostCmdList.Add(CString(MAKEINTRESOURCE(IDS_MENUREBASE)));
2245                 }
2246
2247                 progress.m_GitCmd=cmd;
2248                 INT_PTR userResponse;
2249
2250                 if (g_Git.UsingLibGit2(CGit::GIT_CMD_FETCH))
2251                 {
2252                         CGitProgressDlg gitdlg;
2253                         if (!dlg.m_bAllRemotes)
2254                                 gitdlg.SetUrl(url);
2255                         gitdlg.SetCommand(CGitProgressList::GitProgress_Fetch);
2256                         gitdlg.SetAutoTag(dlg.m_bFetchTags ? GIT_REMOTE_DOWNLOAD_TAGS_ALL : GIT_REMOTE_DOWNLOAD_TAGS_NONE);
2257                         if (!dlg.m_bAllRemotes)
2258                                 gitdlg.SetRefSpec(dlg.m_RemoteBranchName);
2259                         userResponse = gitdlg.DoModal();
2260
2261                 }
2262                 else
2263                         userResponse = progress.DoModal();
2264
2265                 if (userResponse == IDC_PROGRESS_BUTTON1)
2266                 {
2267                         CString cmd = _T("/command:log");
2268                         cmd += _T(" /path:\"") + g_Git.m_CurrentDir + _T("\"");
2269                         RunTortoiseGitProc(cmd);
2270                         return TRUE;
2271                 }
2272                 else if (userResponse == IDC_PROGRESS_BUTTON1 + 1)
2273                 {
2274                         CString currentBranch = g_Git.GetSymbolicRef();
2275                         CString configName;
2276                         configName.Format(_T("branch.%s.remote"), currentBranch);
2277                         CString pullRemote = g_Git.GetConfigValue(configName);
2278
2279                         //Select pull-branch from current branch
2280                         configName.Format(_T("branch.%s.merge"), currentBranch);
2281                         CString pullBranch = CGit::StripRefName(g_Git.GetConfigValue(configName));
2282
2283                         CString defaultUpstream;
2284                         if (!pullRemote.IsEmpty() && !pullBranch.IsEmpty())
2285                                 defaultUpstream.Format(_T("remotes/%s/%s"), pullRemote, pullBranch);
2286                         GitReset(&defaultUpstream, 2);
2287                         return TRUE;
2288                 }
2289                 else if ((userResponse == IDC_PROGRESS_BUTTON1 + 2) || (progress.m_GitStatus == 0 && dlg.m_bRebase))
2290                 {
2291                         while(1)
2292                         {
2293                                 CRebaseDlg dlg;
2294                                 dlg.m_PostButtonTexts.Add(CString(MAKEINTRESOURCE(IDS_MENULOG)));
2295                                 dlg.m_PostButtonTexts.Add(CString(MAKEINTRESOURCE(IDS_MENUDESSENDMAIL)));
2296                                 dlg.m_PostButtonTexts.Add(CString(MAKEINTRESOURCE(IDS_MENUREBASE)));
2297                                 INT_PTR response = dlg.DoModal();
2298                                 if(response == IDOK)
2299                                 {
2300                                         return TRUE;
2301                                 }
2302                                 else if (response == IDC_REBASE_POST_BUTTON)
2303                                 {
2304                                         CString cmd = _T("/command:log");
2305                                         cmd += _T(" /path:\"") + g_Git.m_CurrentDir + _T("\"");
2306                                         RunTortoiseGitProc(cmd);
2307                                         return TRUE;
2308                                 }
2309                                 else if (response == IDC_REBASE_POST_BUTTON + 1)
2310                                 {
2311                                         CString cmd, out, err;
2312                                         cmd.Format(_T("git.exe  format-patch -o \"%s\" %s..%s"),
2313                                                 g_Git.m_CurrentDir,
2314                                                 g_Git.FixBranchName(dlg.m_Upstream),
2315                                                 g_Git.FixBranchName(dlg.m_Branch));
2316                                         if (g_Git.Run(cmd, &out, &err, CP_UTF8))
2317                                         {
2318                                                 CMessageBox::Show(NULL, out + L"\n" + err, _T("TortoiseGit"), MB_OK|MB_ICONERROR);
2319                                                 return FALSE;
2320                                         }
2321
2322                                         CAppUtils::SendPatchMail(cmd,out);
2323                                         return TRUE;
2324                                 }
2325                                 else if (response == IDC_REBASE_POST_BUTTON + 2)
2326                                         continue;
2327                                 else if(response == IDCANCEL)
2328                                         return FALSE;
2329                         }
2330                         return TRUE;
2331                 }
2332                 else if (userResponse != IDCANCEL)
2333                         return TRUE;
2334         }
2335         return FALSE;
2336 }
2337
2338 bool CAppUtils::Push(CString selectLocalBranch, bool autoClose)
2339 {
2340         CPushDlg dlg;
2341         dlg.m_BranchSourceName = selectLocalBranch;
2342         CString error;
2343         DWORD exitcode = 0xFFFFFFFF;
2344         CTGitPathList list;
2345         list.AddPath(CTGitPath(g_Git.m_CurrentDir));
2346         if (CHooks::Instance().PrePush(list,exitcode, error))
2347         {
2348                 if (exitcode)
2349                 {
2350                         CString temp;
2351                         temp.Format(IDS_ERR_HOOKFAILED, (LPCTSTR)error);
2352                         //ReportError(temp);
2353                         CMessageBox::Show(NULL,temp,_T("TortoiseGit"),MB_OK|MB_ICONERROR);
2354                         return false;
2355                 }
2356         }
2357
2358         if(dlg.DoModal()==IDOK)
2359         {
2360                 CString arg;
2361
2362                 if(dlg.m_bPack)
2363                         arg += _T("--thin ");
2364                 if(dlg.m_bTags && !dlg.m_bPushAllBranches)
2365                         arg += _T("--tags ");
2366                 if(dlg.m_bForce)
2367                         arg += _T("--force ");
2368                 if (dlg.m_bSetUpstream)
2369                         arg += _T("--set-upstream ");
2370                 if (dlg.m_RecurseSubmodules == 1)
2371                         arg += _T("--recurse-submodules=check ");
2372                 if (dlg.m_RecurseSubmodules == 2)
2373                         arg += _T("--recurse-submodules=on-demand ");
2374
2375                 int ver = CAppUtils::GetMsysgitVersion();
2376
2377                 if(ver >= 0x01070203) //above 1.7.0.2
2378                         arg += _T("--progress ");
2379
2380                 CProgressDlg progress;
2381                 progress.m_bAutoCloseOnSuccess=autoClose;
2382
2383                 STRING_VECTOR remotesList;
2384                 if (dlg.m_bPushAllRemotes)
2385                         g_Git.GetRemoteList(remotesList);
2386                 else
2387                         remotesList.push_back(dlg.m_URL);
2388
2389                 for (unsigned int i = 0; i < remotesList.size(); ++i)
2390                 {
2391                         if (dlg.m_bAutoLoad)
2392                                 CAppUtils::LaunchPAgent(NULL, &remotesList[i]);
2393
2394                         CString cmd;
2395                         if (dlg.m_bPushAllBranches)
2396                         {
2397                                 cmd.Format(_T("git.exe push --all %s \"%s\""),
2398                                                 arg,
2399                                                 remotesList[i]);
2400
2401                                 if (dlg.m_bTags)
2402                                 {
2403                                         progress.m_GitCmdList.push_back(cmd);
2404                                         cmd.Format(_T("git.exe push --tags %s \"%s\""), arg, remotesList[i]);
2405                                 }
2406                         }
2407                         else
2408                         {
2409                                 cmd.Format(_T("git.exe push %s \"%s\" %s"),
2410                                                 arg,
2411                                                 remotesList[i],
2412                                                 dlg.m_BranchSourceName);
2413                                 if (!dlg.m_BranchRemoteName.IsEmpty())
2414                                 {
2415                                         cmd += _T(":") + dlg.m_BranchRemoteName;
2416                                 }
2417                         }
2418                         progress.m_GitCmdList.push_back(cmd);
2419                 }
2420
2421                 progress.m_PostCmdList.Add(CString(MAKEINTRESOURCE(IDS_PROC_REQUESTPULL)));
2422                 progress.m_PostCmdList.Add(CString(MAKEINTRESOURCE(IDS_MENUPUSH)));
2423                 INT_PTR ret = progress.DoModal();
2424
2425                 if(!progress.m_GitStatus)
2426                 {
2427                         if (CHooks::Instance().PostPush(list,exitcode, error))
2428                         {
2429                                 if (exitcode)
2430                                 {
2431                                         CString temp;
2432                                         temp.Format(IDS_ERR_HOOKFAILED, (LPCTSTR)error);
2433                                         //ReportError(temp);
2434                                         CMessageBox::Show(NULL,temp,_T("TortoiseGit"),MB_OK|MB_ICONERROR);
2435                                         return false;
2436                                 }
2437                         }
2438                         if(ret == IDC_PROGRESS_BUTTON1)
2439                         {
2440                                 RequestPull(dlg.m_BranchRemoteName);
2441                         }
2442                         else if(ret == IDC_PROGRESS_BUTTON1 + 1)
2443                         {
2444                                 Push();
2445                         }
2446                         return TRUE;
2447                 }
2448
2449         }
2450         return FALSE;
2451 }
2452
2453 bool CAppUtils::RequestPull(CString endrevision, CString repositoryUrl)
2454 {
2455         CRequestPullDlg dlg;
2456         dlg.m_RepositoryURL = repositoryUrl;
2457         dlg.m_EndRevision = endrevision;
2458         if (dlg.DoModal()==IDOK)
2459         {
2460                 CString cmd;
2461                 cmd.Format(_T("git.exe request-pull %s \"%s\" %s"), dlg.m_StartRevision, dlg.m_RepositoryURL, dlg.m_EndRevision);
2462
2463                 CSysProgressDlg sysProgressDlg;
2464                 sysProgressDlg.SetTitle(CString(MAKEINTRESOURCE(IDS_APPNAME)));
2465                 sysProgressDlg.SetLine(1, CString(MAKEINTRESOURCE(IDS_PROC_CREATINGPULLREUQEST)));
2466                 sysProgressDlg.SetLine(2, CString(MAKEINTRESOURCE(IDS_PROGRESSWAIT)));
2467                 sysProgressDlg.SetShowProgressBar(false);
2468                 sysProgressDlg.ShowModeless((HWND)NULL, true);
2469
2470                 CString tempFileName = GetTempFile();
2471                 DeleteFile(tempFileName);
2472                 CreateDirectory(tempFileName, NULL);
2473                 tempFileName += _T("\\pullrequest.txt");
2474                 if (g_Git.RunLogFile(cmd, tempFileName))
2475                 {
2476                         CMessageBox::Show(NULL, IDS_ERR_PULLREUQESTFAILED, IDS_APPNAME, MB_OK);
2477                         return false;
2478                 }
2479
2480                 if (sysProgressDlg.HasUserCancelled())
2481                 {
2482                         CMessageBox::Show(NULL, IDS_SVN_USERCANCELLED, IDS_APPNAME, MB_OK);
2483                         ::DeleteFile(tempFileName);
2484                         return false;
2485                 }
2486
2487                 sysProgressDlg.Stop();
2488
2489                 if (dlg.m_bSendMail)
2490                 {
2491                         CSendMailDlg dlg;
2492                         dlg.m_PathList = CTGitPathList(CTGitPath(tempFileName));
2493                         dlg.m_bCustomSubject = true;
2494
2495                         if (dlg.DoModal() == IDOK)
2496                         {
2497                                 if(dlg.m_PathList.GetCount() == 0)
2498                                         return FALSE;
2499
2500                                 CGitProgressDlg progDlg;
2501
2502                                 theApp.m_pMainWnd = &progDlg;
2503                                 progDlg.SetCommand(CGitProgressList::GitProgress_SendMail);
2504
2505                                 progDlg.SetPathList(dlg.m_PathList);
2506                                 progDlg.SetItemCount(dlg.m_PathList.GetCount());
2507
2508                                 CSendMailCombineable sendMailCombineable(dlg.m_To, dlg.m_CC, dlg.m_Subject, !!dlg.m_bAttachment, !!dlg.m_bCombine, !!dlg.m_bUseMAPI);
2509                                 progDlg.SetSendMailOption(&sendMailCombineable);
2510
2511                                 progDlg.DoModal();
2512
2513                                 return true;
2514                         }
2515                         return false;
2516                 }
2517
2518                 CAppUtils::LaunchAlternativeEditor(tempFileName);
2519         }
2520         return true;
2521 }
2522
2523 bool CAppUtils::CreateMultipleDirectory(const CString& szPath)
2524 {
2525         CString strDir(szPath);
2526         if (strDir.GetAt(strDir.GetLength()-1)!=_T('\\'))
2527         {
2528                 strDir.AppendChar(_T('\\'));
2529         }
2530         std::vector<CString> vPath;
2531         CString strTemp;
2532         bool bSuccess = false;
2533
2534         for (int i=0;i<strDir.GetLength();++i)
2535         {
2536                 if (strDir.GetAt(i) != _T('\\'))
2537                 {
2538                         strTemp.AppendChar(strDir.GetAt(i));
2539                 }
2540                 else
2541                 {
2542                         vPath.push_back(strTemp);
2543                         strTemp.AppendChar(_T('\\'));
2544                 }
2545         }
2546
2547         for (auto vIter = vPath.begin(); vIter != vPath.end(); ++vIter)
2548         {
2549                 bSuccess = CreateDirectory(*vIter, NULL) ? true : false;
2550         }
2551
2552         return bSuccess;
2553 }
2554
2555 void CAppUtils::RemoveTrailSlash(CString &path)
2556 {
2557         if(path.IsEmpty())
2558                 return ;
2559
2560         // For URL, do not trim the slash just after the host name component.
2561         int index = path.Find(_T("://"));
2562         if (index >= 0)
2563         {
2564                 index += 4;
2565                 index = path.Find(_T('/'), index);
2566                 if (index == path.GetLength() - 1)
2567                         return;
2568         }
2569
2570         while(path[path.GetLength()-1] == _T('\\') || path[path.GetLength()-1] == _T('/' ) )
2571         {
2572                 path=path.Left(path.GetLength()-1);
2573                 if(path.IsEmpty())
2574                         return;
2575         }
2576 }
2577
2578 bool CAppUtils::CheckUserData()
2579 {
2580         while(g_Git.GetUserName().IsEmpty() || g_Git.GetUserEmail().IsEmpty())
2581         {
2582                 if(CMessageBox::Show(NULL, IDS_PROC_NOUSERDATA, IDS_APPNAME, MB_YESNO| MB_ICONERROR) == IDYES)
2583                 {
2584                         CTGitPath path(g_Git.m_CurrentDir);
2585                         CSettings dlg(IDS_PROC_SETTINGS_TITLE,&path);
2586                         dlg.SetTreeViewMode(TRUE, TRUE, TRUE);
2587                         dlg.SetTreeWidth(220);
2588                         dlg.m_DefaultPage = _T("gitconfig");
2589
2590                         dlg.DoModal();
2591                         dlg.HandleRestart();
2592
2593                 }
2594                 else
2595                         return false;
2596         }
2597
2598         return true;
2599 }
2600
2601 BOOL CAppUtils::Commit(CString bugid,BOOL bWholeProject,CString &sLogMsg,
2602                                         CTGitPathList &pathList,
2603                                         CTGitPathList &selectedList,
2604                                         bool bSelectFilesForCommit,
2605                                         bool autoClose)
2606 {
2607         bool bFailed = true;
2608
2609         if (!CheckUserData())
2610                 return false;
2611
2612         while (bFailed)
2613         {
2614                 bFailed = false;
2615                 CCommitDlg dlg;
2616                 dlg.m_sBugID = bugid;
2617
2618                 dlg.m_bWholeProject = bWholeProject;
2619
2620                 dlg.m_sLogMessage = sLogMsg;
2621                 dlg.m_pathList = pathList;
2622                 dlg.m_checkedPathList = selectedList;
2623                 dlg.m_bSelectFilesForCommit = bSelectFilesForCommit;
2624                 dlg.m_bAutoClose = autoClose;
2625                 if (dlg.DoModal() == IDOK)
2626                 {
2627                         if (dlg.m_pathList.GetCount()==0)
2628                                 return false;
2629                         // if the user hasn't changed the list of selected items
2630                         // we don't use that list. Because if we would use the list
2631                         // of pre-checked items, the dialog would show different
2632                         // checked items on the next startup: it would only try
2633                         // to check the parent folder (which might not even show)
2634                         // instead, we simply use an empty list and let the
2635                         // default checking do its job.
2636                         if (!dlg.m_pathList.IsEqual(pathList))
2637                                 selectedList = dlg.m_pathList;
2638                         pathList = dlg.m_updatedPathList;
2639                         sLogMsg = dlg.m_sLogMessage;
2640                         bSelectFilesForCommit = true;
2641
2642                         if( dlg.m_bPushAfterCommit )
2643                         {
2644                                 switch(dlg.m_PostCmd)
2645                                 {
2646                                 case GIT_POST_CMD_DCOMMIT:
2647                                         CAppUtils::SVNDCommit();
2648                                         break;
2649                                 default:
2650                                         CAppUtils::Push();
2651                                 }
2652                         }
2653                         else if (dlg.m_bCreateTagAfterCommit)
2654                         {
2655                                 CAppUtils::CreateBranchTag(TRUE);
2656                         }
2657
2658 //                      CGitProgressDlg progDlg;
2659 //                      progDlg.SetChangeList(dlg.m_sChangeList, !!dlg.m_bKeepChangeList);
2660 //                      if (parser.HasVal(_T("closeonend")))
2661 //                              progDlg.SetAutoClose(parser.GetLongVal(_T("closeonend")));
2662 //                      progDlg.SetCommand(CGitProgressDlg::GitProgress_Commit);
2663 //                      progDlg.SetOptions(dlg.m_bKeepLocks ? ProgOptKeeplocks : ProgOptNone);
2664 //                      progDlg.SetPathList(dlg.m_pathList);
2665 //                      progDlg.SetCommitMessage(dlg.m_sLogMessage);
2666 //                      progDlg.SetDepth(dlg.m_bRecursive ? Git_depth_infinity : svn_depth_empty);
2667 //                      progDlg.SetSelectedList(dlg.m_selectedPathList);
2668 //                      progDlg.SetItemCount(dlg.m_itemsCount);
2669 //                      progDlg.SetBugTraqProvider(dlg.m_BugTraqProvider);
2670 //                      progDlg.DoModal();
2671 //                      CRegDWORD err = CRegDWORD(_T("Software\\TortoiseGit\\ErrorOccurred"), FALSE);
2672 //                      err = (DWORD)progDlg.DidErrorsOccur();
2673 //                      bFailed = progDlg.DidErrorsOccur();
2674 //                      bRet = progDlg.DidErrorsOccur();
2675 //                      CRegDWORD bFailRepeat = CRegDWORD(_T("Software\\TortoiseGit\\CommitReopen"), FALSE);
2676 //                      if (DWORD(bFailRepeat)==0)
2677 //                              bFailed = false;                // do not repeat if the user chose not to in the settings.
2678                 }
2679         }
2680         return true;
2681 }
2682
2683
2684 BOOL CAppUtils::SVNDCommit()
2685 {
2686         CSVNDCommitDlg dcommitdlg;
2687         CString gitSetting = g_Git.GetConfigValue(_T("svn.rmdir"));
2688         if (gitSetting == _T("")) {
2689                 if (dcommitdlg.DoModal() != IDOK)
2690                 {
2691                         return false;
2692                 }
2693                 else
2694                 {
2695                         if (dcommitdlg.m_remember)
2696                         {
2697                                 if (dcommitdlg.m_rmdir)
2698                                 {
2699                                         gitSetting = _T("true");
2700                                 }
2701                                 else
2702                                 {
2703                                         gitSetting = _T("false");
2704                                 }
2705                                 if(g_Git.SetConfigValue(_T("svn.rmdir"),gitSetting))
2706                                 {
2707                                         CString msg;
2708                                         msg.Format(IDS_PROC_SAVECONFIGFAILED, _T("svn.rmdir"), gitSetting);
2709                                         CMessageBox::Show(NULL, msg, _T("TortoiseGit"), MB_OK | MB_ICONERROR);
2710                                 }
2711                         }
2712                 }
2713         }
2714
2715         BOOL IsStash = false;
2716         if(!g_Git.CheckCleanWorkTree())
2717         {
2718                 if (CMessageBox::Show(NULL, IDS_ERROR_NOCLEAN_STASH, IDS_APPNAME, 1, IDI_QUESTION, IDS_STASHBUTTON, IDS_ABORTBUTTON) == 1)
2719                 {
2720                         CSysProgressDlg sysProgressDlg;
2721                         sysProgressDlg.SetTitle(CString(MAKEINTRESOURCE(IDS_APPNAME)));
2722                         sysProgressDlg.SetLine(1, CString(MAKEINTRESOURCE(IDS_PROC_STASHRUNNING)));
2723                         sysProgressDlg.SetLine(2, CString(MAKEINTRESOURCE(IDS_PROGRESSWAIT)));
2724                         sysProgressDlg.SetShowProgressBar(false);
2725                         sysProgressDlg.SetCancelMsg(IDS_PROGRS_INFOFAILED);
2726                         sysProgressDlg.ShowModeless((HWND)NULL, true);
2727
2728                         CString cmd,out;
2729                         cmd=_T("git.exe stash");
2730                         if (g_Git.Run(cmd, &out, CP_UTF8))
2731                         {
2732                                 sysProgressDlg.Stop();
2733                                 CMessageBox::Show(NULL,out,_T("TortoiseGit"),MB_OK);
2734                                 return false;
2735                         }
2736                         sysProgressDlg.Stop();
2737
2738                         IsStash =true;
2739                 }
2740                 else
2741                 {
2742                         return false;
2743                 }
2744         }
2745
2746         CProgressDlg progress;
2747         if (dcommitdlg.m_rmdir)
2748         {
2749                 progress.m_GitCmd=_T("git.exe svn dcommit --rmdir");
2750         }
2751         else
2752         {
2753                 progress.m_GitCmd=_T("git.exe svn dcommit");
2754         }
2755         if(progress.DoModal()==IDOK && progress.m_GitStatus == 0)
2756         {
2757                 if( IsStash)
2758                 {
2759                         if(CMessageBox::Show(NULL,IDS_DCOMMIT_STASH_POP,IDS_APPNAME,MB_YESNO|MB_ICONINFORMATION)==IDYES)
2760                         {
2761                                 CSysProgressDlg sysProgressDlg;
2762                                 sysProgressDlg.SetTitle(CString(MAKEINTRESOURCE(IDS_APPNAME)));
2763                                 sysProgressDlg.SetLine(1, CString(MAKEINTRESOURCE(IDS_PROC_STASHRUNNING)));
2764                                 sysProgressDlg.SetLine(2, CString(MAKEINTRESOURCE(IDS_PROGRESSWAIT)));
2765                                 sysProgressDlg.SetShowProgressBar(false);
2766                                 sysProgressDlg.SetCancelMsg(IDS_PROGRS_INFOFAILED);
2767                                 sysProgressDlg.ShowModeless((HWND)NULL, true);
2768
2769                                 CString cmd,out;
2770                                 cmd=_T("git.exe stash pop");
2771                                 if (g_Git.Run(cmd, &out, CP_UTF8))
2772                                 {
2773                                         sysProgressDlg.Stop();
2774                                         CMessageBox::Show(NULL,out,_T("TortoiseGit"),MB_OK);
2775                                         return false;
2776                                 }
2777                                 sysProgressDlg.Stop();
2778                         }
2779                         else
2780                         {
2781                                 return false;
2782                         }
2783                 }
2784                 return TRUE;
2785         }
2786         return FALSE;
2787 }
2788
2789 static void MergeCallback(CProgressDlg *dlg, void * /*caller*/, int result)
2790 {
2791         if (result)
2792         {
2793                 dlg->m_PostCmdList.RemoveAll();
2794
2795                 CTGitPathList list;
2796                 if (!g_Git.ListConflictFile(list) && list.GetCount() > 0)
2797                 {
2798                         // there are conflict files
2799                         dlg->m_PostCmdList.Add(CString(MAKEINTRESOURCE(IDS_PROGRS_CMD_RESOLVE)));
2800                 }
2801         }
2802 }
2803
2804 BOOL CAppUtils::Merge(CString *commit)
2805 {
2806         if (!CheckUserData())
2807                 return FALSE;
2808
2809         CMergeDlg dlg;
2810         if(commit)
2811                 dlg.m_initialRefName = *commit;
2812
2813         if(dlg.DoModal()==IDOK)
2814         {
2815                 CString cmd;
2816                 CString args;
2817
2818                 if(dlg.m_bNoFF)
2819                         args += _T(" --no-ff");
2820
2821                 if(dlg.m_bSquash)
2822                         args += _T(" --squash");
2823
2824                 if(dlg.m_bNoCommit)
2825                         args += _T(" --no-commit");
2826
2827                 if (dlg.m_bLog)
2828                 {
2829                         CString fmt;
2830                         fmt.Format(_T(" --log=%d"), dlg.m_nLog);
2831                         args += fmt;
2832                 }
2833
2834                 if (!dlg.m_MergeStrategy.IsEmpty())
2835                 {
2836                         args += _T(" --strategy=") + dlg.m_MergeStrategy;
2837                         if (!dlg.m_StrategyOption.IsEmpty())
2838                         {
2839                                 args += _T(" --strategy-option=") + dlg.m_StrategyOption;
2840                                 if (!dlg.m_StrategyParam.IsEmpty())
2841                                         args += _T("=") + dlg.m_StrategyParam;
2842                         }
2843                 }
2844
2845                 if(!dlg.m_strLogMesage.IsEmpty())
2846                 {
2847                         CString logmsg = dlg.m_strLogMesage;
2848                         logmsg.Replace(_T("\""), _T("\\\""));
2849                         args += _T(" -m \"") + logmsg + _T("\"");
2850                 }
2851                 cmd.Format(_T("git.exe merge %s %s"), args, g_Git.FixBranchName(dlg.m_VersionName));
2852
2853                 CProgressDlg Prodlg;
2854                 Prodlg.m_GitCmd = cmd;
2855
2856                 if (dlg.m_bNoCommit)
2857                         Prodlg.m_PostCmdList.Add(CString(MAKEINTRESOURCE(IDS_MENUCOMMIT)));
2858                 else if (dlg.m_bIsBranch)
2859                         Prodlg.m_PostCmdList.Add(CString(MAKEINTRESOURCE(IDS_PROC_REMOVEBRANCH)));
2860
2861                 Prodlg.m_PostCmdCallback = MergeCallback;
2862
2863                 INT_PTR ret = Prodlg.DoModal();
2864                 if (Prodlg.m_GitStatus != 0 && ret == IDC_PROGRESS_BUTTON1)
2865                 {
2866                         CTGitPathList pathlist;
2867                         CTGitPathList selectedlist;
2868                         pathlist.AddPath(g_Git.m_CurrentDir);
2869                         bool bSelectFilesForCommit = !!DWORD(CRegStdDWORD(_T("Software\\TortoiseGit\\SelectFilesForCommit"), TRUE));
2870                         CString str;
2871                         CAppUtils::Commit(CString(), false, str, pathlist, selectedlist, bSelectFilesForCommit);
2872                 }
2873                 else if (ret == IDC_PROGRESS_BUTTON1)
2874                 {
2875                         if (dlg.m_bNoCommit)
2876                         {
2877                                 CString sLogMsg;
2878                                 CTGitPathList pathList;
2879                                 CTGitPathList selectedList;
2880                                 return Commit(_T(""), TRUE, sLogMsg, pathList, selectedList, true);
2881                         }
2882                         else if (dlg.m_bIsBranch)
2883                         {
2884                                 CString msg;
2885                                 msg.Format(IDS_PROC_DELETEBRANCHTAG, dlg.m_VersionName);
2886                                 if (CMessageBox::Show(NULL, msg, _T("TortoiseGit"), 2, IDI_QUESTION, CString(MAKEINTRESOURCE(IDS_DELETEBUTTON)), CString(MAKEINTRESOURCE(IDS_ABORTBUTTON))) == 1)
2887                                 {
2888                                         CString cmd, out;
2889                                         cmd.Format(_T("git.exe branch -D -- %s"), dlg.m_VersionName);
2890                                         if (g_Git.Run(cmd, &out, CP_UTF8))
2891                                                 MessageBox(NULL, out, _T("TortoiseGit"), MB_OK);
2892                                 }
2893                         }
2894                 }
2895
2896                 return !Prodlg.m_GitStatus;
2897         }
2898         return false;
2899 }
2900
2901 void CAppUtils::EditNote(GitRev *rev)
2902 {
2903         if (!CheckUserData())
2904                 return;
2905
2906         CInputDlg dlg;
2907         dlg.m_sHintText = CString(MAKEINTRESOURCE(IDS_PROGS_TITLE_EDITNOTES));
2908         dlg.m_sInputText = rev->m_Notes;
2909         dlg.m_sTitle = CString(MAKEINTRESOURCE(IDS_PROGS_TITLE_EDITNOTES));
2910         //dlg.m_pProjectProperties = &m_ProjectProperties;
2911         dlg.m_bUseLogWidth = true;
2912         if(dlg.DoModal() == IDOK)
2913         {
2914                 CString cmd,output;
2915                 cmd=_T("notes add -f -F \"");
2916
2917                 CString tempfile=::GetTempFile();
2918                 CAppUtils::SaveCommitUnicodeFile(tempfile,dlg.m_sInputText);
2919                 cmd += tempfile;
2920                 cmd += _T("\" ");
2921                 cmd += rev->m_CommitHash.ToString();
2922
2923                 try
2924                 {
2925                         if (git_run_cmd("notes", CUnicodeUtils::GetMulti(cmd, CP_UTF8).GetBuffer()))
2926                         {
2927                                 CMessageBox::Show(NULL, IDS_PROC_FAILEDSAVINGNOTES, IDS_APPNAME, MB_OK | MB_ICONERROR);
2928
2929                         }
2930                         else
2931                         {
2932                                 rev->m_Notes = dlg.m_sInputText;
2933                         }
2934                 }catch(...)
2935                 {
2936                         CMessageBox::Show(NULL, IDS_PROC_FAILEDSAVINGNOTES, IDS_APPNAME, MB_OK | MB_ICONERROR);
2937                 }
2938                 CFile::Remove(tempfile);
2939
2940         }
2941 }
2942
2943 int CAppUtils::GetMsysgitVersion(CString *versionstr)
2944 {
2945         CString cmd;
2946         CString versiondebug;
2947         CString version;
2948
2949         CRegDWORD regTime               = CRegDWORD(_T("Software\\TortoiseGit\\git_file_time"));
2950         CRegDWORD regVersion    = CRegDWORD(_T("Software\\TortoiseGit\\git_cached_version"));
2951
2952         CString gitpath = CGit::ms_LastMsysGitDir+_T("\\git.exe");
2953
2954         __int64 time=0;
2955         if(!g_Git.GetFileModifyTime(gitpath, &time) && !versionstr)
2956         {
2957                 if((DWORD)time == regTime)
2958                 {
2959                         return regVersion;
2960                 }
2961         }
2962
2963         if(versionstr)
2964                 version = *versionstr;
2965         else
2966         {
2967                 CString err;
2968                 cmd = _T("git.exe --version");
2969                 if (g_Git.Run(cmd, &version, &err, CP_UTF8))
2970                 {
2971                         CMessageBox::Show(NULL, _T("git.exe not correctly set up (") + err + _T(")\nCheck TortoiseGit settings and consult help file for \"Git.exe Path\"."), _T("TortoiseGit"), MB_OK|MB_ICONERROR);
2972                         return false;
2973                 }
2974         }
2975
2976         int start=0;
2977         int ver = 0;
2978
2979         versiondebug = version;
2980
2981         try
2982         {
2983                 CString str=version.Tokenize(_T("."), start);
2984                 int space = str.ReverseFind(_T(' '));
2985                 str = str.Mid(space+1,start);
2986                 ver = _ttol(str);
2987                 ver <<=24;
2988
2989                 version = version.Mid(start);
2990                 start = 0;
2991
2992                 str = version.Tokenize(_T("."), start);
2993
2994                 ver |= (_ttol(str) & 0xFF) << 16;
2995
2996                 str = version.Tokenize(_T("."), start);
2997                 ver |= (_ttol(str) & 0xFF) << 8;
2998
2999                 str = version.Tokenize(_T("."), start);
3000                 ver |= (_ttol(str) & 0xFF);
3001         }
3002         catch(...)
3003         {
3004                 if (!ver)
3005                 {
3006                         CMessageBox::Show(NULL, _T("Could not parse git.exe version number: \"") + versiondebug + _T("\""), _T("TortoiseGit"), MB_OK | MB_ICONERROR);
3007                         return false;
3008                 }
3009         }
3010
3011         regTime = time&0xFFFFFFFF;
3012         regVersion = ver;
3013
3014         return ver;
3015 }
3016
3017 void CAppUtils::MarkWindowAsUnpinnable(HWND hWnd)
3018 {
3019         typedef HRESULT (WINAPI *SHGPSFW) (HWND hwnd,REFIID riid,void** ppv);
3020
3021         CAutoLibrary hShell = AtlLoadSystemLibraryUsingFullPath(_T("Shell32.dll"));
3022
3023         if (hShell.IsValid()) {
3024                 SHGPSFW pfnSHGPSFW = (SHGPSFW)::GetProcAddress(hShell, "SHGetPropertyStoreForWindow");
3025                 if (pfnSHGPSFW) {
3026                         IPropertyStore *pps;
3027                         HRESULT hr = pfnSHGPSFW(hWnd, IID_PPV_ARGS(&pps));
3028                         if (SUCCEEDED(hr)) {
3029                                 PROPVARIANT var;
3030                                 var.vt = VT_BOOL;
3031                                 var.boolVal = VARIANT_TRUE;
3032                                 hr = pps->SetValue(PKEY_AppUserModel_PreventPinning, var);
3033                                 pps->Release();
3034                         }
3035                 }
3036         }
3037 }
3038
3039 void CAppUtils::SetWindowTitle(HWND hWnd, const CString& urlorpath, const CString& dialogname)
3040 {
3041         ASSERT(dialogname.GetLength() < 70);
3042         ASSERT(urlorpath.GetLength() < MAX_PATH);
3043         WCHAR pathbuf[MAX_PATH] = {0};
3044
3045         PathCompactPathEx(pathbuf, urlorpath, 70 - dialogname.GetLength(), 0);
3046
3047         wcscat_s(pathbuf, L" - ");
3048         wcscat_s(pathbuf, dialogname);
3049         wcscat_s(pathbuf, L" - ");
3050         wcscat_s(pathbuf, CString(MAKEINTRESOURCE(IDS_APPNAME)));
3051         SetWindowText(hWnd, pathbuf);
3052 }
3053
3054 bool CAppUtils::BisectStart(CString lastGood, CString firstBad, bool autoClose)
3055 {
3056         if (!g_Git.CheckCleanWorkTree())
3057         {
3058                 if (CMessageBox::Show(NULL, IDS_ERROR_NOCLEAN_STASH, IDS_APPNAME, 1, IDI_QUESTION, IDS_STASHBUTTON, IDS_ABORTBUTTON) == 1)
3059                 {
3060                         CSysProgressDlg sysProgressDlg;
3061                         sysProgressDlg.SetTitle(CString(MAKEINTRESOURCE(IDS_APPNAME)));
3062                         sysProgressDlg.SetLine(1, CString(MAKEINTRESOURCE(IDS_PROC_STASHRUNNING)));
3063                         sysProgressDlg.SetLine(2, CString(MAKEINTRESOURCE(IDS_PROGRESSWAIT)));
3064                         sysProgressDlg.SetShowProgressBar(false);
3065                         sysProgressDlg.SetCancelMsg(IDS_PROGRS_INFOFAILED);
3066                         sysProgressDlg.ShowModeless((HWND)NULL, true);
3067
3068                         CString cmd, out;
3069                         cmd = _T("git.exe stash");
3070                         if (g_Git.Run(cmd, &out, CP_UTF8))
3071                         {
3072                                 sysProgressDlg.Stop();
3073                                 CMessageBox::Show(NULL, out, _T("TortoiseGit"), MB_OK);
3074                                 return false;
3075                         }
3076                         sysProgressDlg.Stop();
3077                 }
3078                 else
3079                         return false;
3080         }
3081
3082         CBisectStartDlg bisectStartDlg;
3083
3084         if (!lastGood.IsEmpty())
3085                 bisectStartDlg.m_sLastGood = lastGood;
3086         if (!firstBad.IsEmpty())
3087                 bisectStartDlg.m_sFirstBad = firstBad;
3088
3089         if (bisectStartDlg.DoModal() == IDOK)
3090         {
3091                 CProgressDlg progress;
3092                 theApp.m_pMainWnd = &progress;
3093                 progress.m_bAutoCloseOnSuccess = autoClose;
3094                 progress.m_GitCmdList.push_back(_T("git.exe bisect start"));
3095                 progress.m_GitCmdList.push_back(_T("git.exe bisect good ") + bisectStartDlg.m_LastGoodRevision);
3096                 progress.m_GitCmdList.push_back(_T("git.exe bisect bad ") + bisectStartDlg.m_FirstBadRevision);
3097
3098                 CTGitPath path(g_Git.m_CurrentDir);
3099
3100                 if (path.HasSubmodules())
3101                         progress.m_PostCmdList.Add(CString(MAKEINTRESOURCE(IDS_PROC_SUBMODULESUPDATE)));
3102
3103                 INT_PTR ret = progress.DoModal();
3104                 if (path.HasSubmodules() && ret == IDC_PROGRESS_BUTTON1)
3105                 {
3106                         CString sCmd;
3107                         sCmd.Format(_T("/command:subupdate /bkpath:\"%s\""), g_Git.m_CurrentDir);
3108
3109                         CAppUtils::RunTortoiseGitProc(sCmd);
3110                         return true;
3111                 }
3112                 else if (ret == IDOK)
3113                         return true;
3114         }
3115
3116         return false;
3117 }
3118
3119 int CAppUtils::Git2GetUserPassword(git_cred **out, const char *url, const char *username_from_url, unsigned int /*allowed_types*/, void * /*payload*/)
3120 {
3121         CUserPassword dlg;
3122         dlg.m_URL = CUnicodeUtils::GetUnicode(url, CP_UTF8);
3123         if (username_from_url)
3124                 dlg.m_UserName = CUnicodeUtils::GetUnicode(username_from_url, CP_UTF8);
3125
3126         CStringA username, password;
3127         if (dlg.DoModal() == IDOK)
3128         {
3129                 username = CUnicodeUtils::GetMulti(dlg.m_UserName, CP_UTF8);
3130                 password = CUnicodeUtils::GetMulti(dlg.m_Password, CP_UTF8);
3131                 return git_cred_userpass_plaintext_new(out, username, password);
3132         }
3133         return -1;
3134 }