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