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