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