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