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