?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Correctly deallocate buffer
[TortoiseGit.git] / src / TortoiseProc / AppUtils.cpp
blob13aef6abf5baebbcabc8c691ebcb4c0cc4c51562
1 // TortoiseGit - a Windows shell extension for easy version control
2
3 // Copyright (C) 2008-2012 - 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 CAppUtils::ConflictEdit(CTGitPath &path,bool /*bAlternativeTool*/,bool revertTheirMy)
1421 {
1422 bool bRet = false;
1423
1424 CTGitPath merge=path;
1425 CTGitPath directory = merge.GetDirectory();
1426
1427 // we have the conflicted file (%merged)
1428 // now look for the other required files
1429 //GitStatus stat;
1430 //stat.GetStatus(merge);
1431 //if (stat.status == NULL)
1432 // return false;
1433
1434 BYTE_VECTOR vector;
1435
1436 CString cmd;
1437 cmd.Format(_T("git.exe ls-files -u -t -z -- \"%s\""),merge.GetGitPathString());
1438
1439 if (g_Git.Run(cmd, &vector))
1440 {
1441 return FALSE;
1442 }
1443
1444 CTGitPathList list;
1445 list.ParserFromLsFile(vector);
1446
1447 if(list.GetCount() == 0)
1448 return FALSE;
1449
1450 CTGitPath theirs;
1451 CTGitPath mine;
1452 CTGitPath base;
1453
1454 if (revertTheirMy)
1455 {
1456 mine.SetFromGit(GetMergeTempFile(_T("REMOTE"), merge));
1457 theirs.SetFromGit(GetMergeTempFile(_T("LOCAL"), merge));
1458 }
1459 else
1460 {
1461 mine.SetFromGit(GetMergeTempFile(_T("LOCAL"), merge));
1462 theirs.SetFromGit(GetMergeTempFile(_T("REMOTE"), merge));
1463 }
1464 base.SetFromGit(GetMergeTempFile(_T("BASE"),merge));
1465
1466 CString format;
1467
1468 //format=_T("git.exe cat-file blob \":%d:%s\"");
1469 format = _T("git checkout-index --temp --stage=%d -- \"%s\"");
1470 CFile tempfile;
1471 //create a empty file, incase stage is not three
1472 tempfile.Open(mine.GetWinPathString(),CFile::modeCreate|CFile::modeReadWrite);
1473 tempfile.Close();
1474 tempfile.Open(theirs.GetWinPathString(),CFile::modeCreate|CFile::modeReadWrite);
1475 tempfile.Close();
1476 tempfile.Open(base.GetWinPathString(),CFile::modeCreate|CFile::modeReadWrite);
1477 tempfile.Close();
1478
1479 bool b_base=false, b_local=false, b_remote=false;
1480
1481 for(int i=0;i<list.GetCount();i++)
1482 {
1483 CString cmd;
1484 CString outfile;
1485 cmd.Empty();
1486 outfile.Empty();
1487
1488 if( list[i].m_Stage == 1)
1489 {
1490 cmd.Format(format, list[i].m_Stage, list[i].GetGitPathString());
1491 b_base = true;
1492 outfile = base.GetWinPathString();
1493
1494 }
1495 if( list[i].m_Stage == 2 )
1496 {
1497 cmd.Format(format, list[i].m_Stage, list[i].GetGitPathString());
1498 b_local = true;
1499 outfile = mine.GetWinPathString();
1500
1501 }
1502 if( list[i].m_Stage == 3 )
1503 {
1504 cmd.Format(format, list[i].m_Stage, list[i].GetGitPathString());
1505 b_remote = true;
1506 outfile = theirs.GetWinPathString();
1507 }
1508 CString output, err;
1509 if(!outfile.IsEmpty())
1510 if (!g_Git.Run(cmd, &output, &err, CP_UTF8))
1511 {
1512 CString file;
1513 int start =0 ;
1514 file = output.Tokenize(_T("\t"), start);
1515 ::MoveFileEx(file,outfile,MOVEFILE_REPLACE_EXISTING|MOVEFILE_COPY_ALLOWED);
1516 }
1517 else
1518 {
1519 CMessageBox::Show(NULL, output + L"\n" + err, _T("TortoiseGit"), MB_OK|MB_ICONERROR);
1520 }
1521 }
1522
1523 if(b_local && b_remote )
1524 {
1525 merge.SetFromWin(g_Git.m_CurrentDir+_T("\\")+merge.GetWinPathString());
1526 if( revertTheirMy )
1527 bRet = !!CAppUtils::StartExtMerge(base, mine, theirs, merge, _T("BASE"), _T("REMOTE"), _T("LOCAL"));
1528 else
1529 bRet = !!CAppUtils::StartExtMerge(base, theirs, mine, merge,_T("BASE"), _T("REMOTE"), _T("LOCAL"));
1530
1531 }
1532 else
1533 {
1534 CFile::Remove(mine.GetWinPathString());
1535 CFile::Remove(theirs.GetWinPathString());
1536 CFile::Remove(base.GetWinPathString());
1537
1538 CDeleteConflictDlg dlg;
1539 DescribeFile(b_local, b_base,dlg.m_LocalStatus);
1540 DescribeFile(b_remote,b_base,dlg.m_RemoteStatus);
1541 dlg.m_bShowModifiedButton=b_base;
1542 dlg.m_File=merge.GetGitPathString();
1543 if(dlg.DoModal() == IDOK)
1544 {
1545 CString cmd,out;
1546 if(dlg.m_bIsDelete)
1547 {
1548 cmd.Format(_T("git.exe rm -- \"%s\""),merge.GetGitPathString());
1549 }
1550 else
1551 cmd.Format(_T("git.exe add -- \"%s\""),merge.GetGitPathString());
1552
1553 if (g_Git.Run(cmd, &out, CP_UTF8))
1554 {
1555 CMessageBox::Show(NULL,out,_T("TortoiseGit"),MB_OK);
1556 return FALSE;
1557 }
1558 return TRUE;
1559 }
1560 else
1561 return FALSE;
1562 }
1563
1564 #if 0
1565 CAppUtils::StartExtMerge(CAppUtils::MergeFlags().AlternativeTool(bAlternativeTool),
1566 base, theirs, mine, merge);
1567 #endif
1568 #if 0
1569 if (stat.status->text_status == svn_wc_status_conflicted)
1570 {
1571 // we have a text conflict, use our merge tool to resolve the conflict
1572
1573 CTSVNPath theirs(directory);
1574 CTSVNPath mine(directory);
1575 CTSVNPath base(directory);
1576 bool bConflictData = false;
1577
1578 if ((stat.status->entry)&&(stat.status->entry->conflict_new))
1579 {
1580 theirs.AppendPathString(CUnicodeUtils::GetUnicode(stat.status->entry->conflict_new));
1581 bConflictData = true;
1582 }
1583 if ((stat.status->entry)&&(stat.status->entry->conflict_old))
1584 {
1585 base.AppendPathString(CUnicodeUtils::GetUnicode(stat.status->entry->conflict_old));
1586 bConflictData = true;
1587 }
1588 if ((stat.status->entry)&&(stat.status->entry->conflict_wrk))
1589 {
1590 mine.AppendPathString(CUnicodeUtils::GetUnicode(stat.status->entry->conflict_wrk));
1591 bConflictData = true;
1592 }
1593 else
1594 {
1595 mine = merge;
1596 }
1597 if (bConflictData)
1598 bRet = !!CAppUtils::StartExtMerge(CAppUtils::MergeFlags().AlternativeTool(bAlternativeTool),
1599 base, theirs, mine, merge);
1600 }
1601
1602 if (stat.status->prop_status == svn_wc_status_conflicted)
1603 {
1604 // we have a property conflict
1605 CTSVNPath prej(directory);
1606 if ((stat.status->entry)&&(stat.status->entry->prejfile))
1607 {
1608 prej.AppendPathString(CUnicodeUtils::GetUnicode(stat.status->entry->prejfile));
1609 // there's a problem: the prej file contains a _description_ of the conflict, and
1610 // that description string might be translated. That means we have no way of parsing
1611 // the file to find out the conflicting values.
1612 // The only thing we can do: show a dialog with the conflict description, then
1613 // let the user either accept the existing property or open the property edit dialog
1614 // to manually change the properties and values. And a button to mark the conflict as
1615 // resolved.
1616 CEditPropConflictDlg dlg;
1617 dlg.SetPrejFile(prej);
1618 dlg.SetConflictedItem(merge);
1619 bRet = (dlg.DoModal() != IDCANCEL);
1620 }
1621 }
1622
1623 if (stat.status->tree_conflict)
1624 {
1625 // we have a tree conflict
1626 SVNInfo info;
1627 const SVNInfoData * pInfoData = info.GetFirstFileInfo(merge, SVNRev(), SVNRev());
1628 if (pInfoData)
1629 {
1630 if (pInfoData->treeconflict_kind == svn_wc_conflict_kind_text)
1631 {
1632 CTSVNPath theirs(directory);
1633 CTSVNPath mine(directory);
1634 CTSVNPath base(directory);
1635 bool bConflictData = false;
1636
1637 if (pInfoData->treeconflict_theirfile)
1638 {
1639 theirs.AppendPathString(pInfoData->treeconflict_theirfile);
1640 bConflictData = true;
1641 }
1642 if (pInfoData->treeconflict_basefile)
1643 {
1644 base.AppendPathString(pInfoData->treeconflict_basefile);
1645 bConflictData = true;
1646 }
1647 if (pInfoData->treeconflict_myfile)
1648 {
1649 mine.AppendPathString(pInfoData->treeconflict_myfile);
1650 bConflictData = true;
1651 }
1652 else
1653 {
1654 mine = merge;
1655 }
1656 if (bConflictData)
1657 bRet = !!CAppUtils::StartExtMerge(CAppUtils::MergeFlags().AlternativeTool(bAlternativeTool),
1658 base, theirs, mine, merge);
1659 }
1660 else if (pInfoData->treeconflict_kind == svn_wc_conflict_kind_tree)
1661 {
1662 CString sConflictAction;
1663 CString sConflictReason;
1664 CString sResolveTheirs;
1665 CString sResolveMine;
1666 CTSVNPath treeConflictPath = CTSVNPath(pInfoData->treeconflict_path);
1667 CString sItemName = treeConflictPath.GetUIFileOrDirectoryName();
1668
1669 if (pInfoData->treeconflict_nodekind == svn_node_file)
1670 {
1671 switch (pInfoData->treeconflict_operation)
1672 {
1673 case svn_wc_operation_update:
1674 switch (pInfoData->treeconflict_action)
1675 {
1676 case svn_wc_conflict_action_edit:
1677 sConflictAction.Format(IDS_TREECONFLICT_FILEUPDATEEDIT, (LPCTSTR)sItemName);
1678 sResolveTheirs.LoadString(IDS_TREECONFLICT_RESOLVE_KEEPREPOSITORYFILE);
1679 break;
1680 case svn_wc_conflict_action_add:
1681 sConflictAction.Format(IDS_TREECONFLICT_FILEUPDATEADD, (LPCTSTR)sItemName);
1682 sResolveTheirs.LoadString(IDS_TREECONFLICT_RESOLVE_KEEPREPOSITORYFILE);
1683 break;
1684 case svn_wc_conflict_action_delete:
1685 sConflictAction.Format(IDS_TREECONFLICT_FILEUPDATEDELETE, (LPCTSTR)sItemName);
1686 sResolveTheirs.LoadString(IDS_TREECONFLICT_RESOLVE_REMOVEFILE);
1687 break;
1688 }
1689 break;
1690 case svn_wc_operation_switch:
1691 switch (pInfoData->treeconflict_action)
1692 {
1693 case svn_wc_conflict_action_edit:
1694 sConflictAction.Format(IDS_TREECONFLICT_FILESWITCHEDIT, (LPCTSTR)sItemName);
1695 sResolveTheirs.LoadString(IDS_TREECONFLICT_RESOLVE_KEEPREPOSITORYFILE);
1696 break;
1697 case svn_wc_conflict_action_add:
1698 sConflictAction.Format(IDS_TREECONFLICT_FILESWITCHADD, (LPCTSTR)sItemName);
1699 sResolveTheirs.LoadString(IDS_TREECONFLICT_RESOLVE_KEEPREPOSITORYFILE);
1700 break;
1701 case svn_wc_conflict_action_delete:
1702 sConflictAction.Format(IDS_TREECONFLICT_FILESWITCHDELETE, (LPCTSTR)sItemName);
1703 sResolveTheirs.LoadString(IDS_TREECONFLICT_RESOLVE_REMOVEFILE);
1704 break;
1705 }
1706 break;
1707 case svn_wc_operation_merge:
1708 switch (pInfoData->treeconflict_action)
1709 {
1710 case svn_wc_conflict_action_edit:
1711 sConflictAction.Format(IDS_TREECONFLICT_FILEMERGEEDIT, (LPCTSTR)sItemName);
1712 sResolveTheirs.LoadString(IDS_TREECONFLICT_RESOLVE_KEEPREPOSITORYFILE);
1713 break;
1714 case svn_wc_conflict_action_add:
1715 sResolveTheirs.Format(IDS_TREECONFLICT_FILEMERGEADD, (LPCTSTR)sItemName);
1716 sResolveTheirs.LoadString(IDS_TREECONFLICT_RESOLVE_KEEPREPOSITORYFILE);
1717 break;
1718 case svn_wc_conflict_action_delete:
1719 sConflictAction.Format(IDS_TREECONFLICT_FILEMERGEDELETE, (LPCTSTR)sItemName);
1720 sResolveTheirs.LoadString(IDS_TREECONFLICT_RESOLVE_REMOVEFILE);
1721 break;
1722 }
1723 break;
1724 }
1725 }
1726 else if (pInfoData->treeconflict_nodekind == svn_node_dir)
1727 {
1728 switch (pInfoData->treeconflict_operation)
1729 {
1730 case svn_wc_operation_update:
1731 switch (pInfoData->treeconflict_action)
1732 {
1733 case svn_wc_conflict_action_edit:
1734 sConflictAction.Format(IDS_TREECONFLICT_DIRUPDATEEDIT, (LPCTSTR)sItemName);
1735 sResolveTheirs.LoadString(IDS_TREECONFLICT_RESOLVE_KEEPREPOSITORYDIR);
1736 break;
1737 case svn_wc_conflict_action_add:
1738 sConflictAction.Format(IDS_TREECONFLICT_DIRUPDATEADD, (LPCTSTR)sItemName);
1739 sResolveTheirs.LoadString(IDS_TREECONFLICT_RESOLVE_KEEPREPOSITORYDIR);
1740 break;
1741 case svn_wc_conflict_action_delete:
1742 sConflictAction.Format(IDS_TREECONFLICT_DIRUPDATEDELETE, (LPCTSTR)sItemName);
1743 sResolveTheirs.LoadString(IDS_TREECONFLICT_RESOLVE_REMOVEDIR);
1744 break;
1745 }
1746 break;
1747 case svn_wc_operation_switch:
1748 switch (pInfoData->treeconflict_action)
1749 {
1750 case svn_wc_conflict_action_edit:
1751 sConflictAction.Format(IDS_TREECONFLICT_DIRSWITCHEDIT, (LPCTSTR)sItemName);
1752 sResolveTheirs.LoadString(IDS_TREECONFLICT_RESOLVE_KEEPREPOSITORYDIR);
1753 break;
1754 case svn_wc_conflict_action_add:
1755 sConflictAction.Format(IDS_TREECONFLICT_DIRSWITCHADD, (LPCTSTR)sItemName);
1756 sResolveTheirs.LoadString(IDS_TREECONFLICT_RESOLVE_KEEPREPOSITORYDIR);
1757 break;
1758 case svn_wc_conflict_action_delete:
1759 sConflictAction.Format(IDS_TREECONFLICT_DIRSWITCHDELETE, (LPCTSTR)sItemName);
1760 sResolveTheirs.LoadString(IDS_TREECONFLICT_RESOLVE_REMOVEDIR);
1761 break;
1762 }
1763 break;
1764 case svn_wc_operation_merge:
1765 switch (pInfoData->treeconflict_action)
1766 {
1767 case svn_wc_conflict_action_edit:
1768 sConflictAction.Format(IDS_TREECONFLICT_DIRMERGEEDIT, (LPCTSTR)sItemName);
1769 sResolveTheirs.LoadString(IDS_TREECONFLICT_RESOLVE_KEEPREPOSITORYDIR);
1770 break;
1771 case svn_wc_conflict_action_add:
1772 sConflictAction.Format(IDS_TREECONFLICT_DIRMERGEADD, (LPCTSTR)sItemName);
1773 sResolveTheirs.LoadString(IDS_TREECONFLICT_RESOLVE_KEEPREPOSITORYDIR);
1774 break;
1775 case svn_wc_conflict_action_delete:
1776 sConflictAction.Format(IDS_TREECONFLICT_DIRMERGEDELETE, (LPCTSTR)sItemName);
1777 sResolveTheirs.LoadString(IDS_TREECONFLICT_RESOLVE_REMOVEDIR);
1778 break;
1779 }
1780 break;
1781 }
1782 }
1783
1784 UINT uReasonID = 0;
1785 switch (pInfoData->treeconflict_reason)
1786 {
1787 case svn_wc_conflict_reason_edited:
1788 uReasonID = IDS_TREECONFLICT_REASON_EDITED;
1789 sResolveMine.LoadString(pInfoData->treeconflict_nodekind == svn_node_dir ? IDS_TREECONFLICT_RESOLVE_KEEPLOCALDIR : IDS_TREECONFLICT_RESOLVE_KEEPLOCALFILE);
1790 break;
1791 case svn_wc_conflict_reason_obstructed:
1792 uReasonID = IDS_TREECONFLICT_REASON_OBSTRUCTED;
1793 sResolveMine.LoadString(pInfoData->treeconflict_nodekind == svn_node_dir ? IDS_TREECONFLICT_RESOLVE_KEEPLOCALDIR : IDS_TREECONFLICT_RESOLVE_KEEPLOCALFILE);
1794 break;
1795 case svn_wc_conflict_reason_deleted:
1796 uReasonID = IDS_TREECONFLICT_REASON_DELETED;
1797 sResolveMine.LoadString(pInfoData->treeconflict_nodekind == svn_node_dir ? IDS_TREECONFLICT_RESOLVE_REMOVEDIR : IDS_TREECONFLICT_RESOLVE_REMOVEFILE);
1798 break;
1799 case svn_wc_conflict_reason_added:
1800 uReasonID = IDS_TREECONFLICT_REASON_ADDED;
1801 sResolveMine.LoadString(pInfoData->treeconflict_nodekind == svn_node_dir ? IDS_TREECONFLICT_RESOLVE_KEEPLOCALDIR : IDS_TREECONFLICT_RESOLVE_KEEPLOCALFILE);
1802 break;
1803 case svn_wc_conflict_reason_missing:
1804 uReasonID = IDS_TREECONFLICT_REASON_MISSING;
1805 sResolveMine.LoadString(pInfoData->treeconflict_nodekind == svn_node_dir ? IDS_TREECONFLICT_RESOLVE_REMOVEDIR : IDS_TREECONFLICT_RESOLVE_REMOVEFILE);
1806 break;
1807 case svn_wc_conflict_reason_unversioned:
1808 uReasonID = IDS_TREECONFLICT_REASON_UNVERSIONED;
1809 sResolveMine.LoadString(pInfoData->treeconflict_nodekind == svn_node_dir ? IDS_TREECONFLICT_RESOLVE_KEEPLOCALDIR : IDS_TREECONFLICT_RESOLVE_KEEPLOCALFILE);
1810 break;
1811 }
1812 sConflictReason.Format(uReasonID, (LPCTSTR)sConflictAction);
1813
1814 CTreeConflictEditorDlg dlg;
1815 dlg.SetConflictInfoText(sConflictReason);
1816 dlg.SetResolveTexts(sResolveTheirs, sResolveMine);
1817 dlg.SetPath(treeConflictPath);
1818 INT_PTR dlgRet = dlg.DoModal();
1819 bRet = (dlgRet != IDCANCEL);
1820 }
1821 }
1822 }
1823 #endif
1824 return bRet;
1825 }
1826
1827 bool CAppUtils::IsSSHPutty()
1828 {
1829 CString sshclient=g_Git.m_Environment.GetEnv(_T("GIT_SSH"));
1830 sshclient=sshclient.MakeLower();
1831 if(sshclient.Find(_T("plink.exe"),0)>=0)
1832 {
1833 return true;
1834 }
1835 return false;
1836 }
1837
1838 CString CAppUtils::GetClipboardLink()
1839 {
1840 if (!OpenClipboard(NULL))
1841 return CString();
1842
1843 CString sClipboardText;
1844 HGLOBAL hglb = GetClipboardData(CF_TEXT);
1845 if (hglb)
1846 {
1847 LPCSTR lpstr = (LPCSTR)GlobalLock(hglb);
1848 sClipboardText = CString(lpstr);
1849 GlobalUnlock(hglb);
1850 }
1851 hglb = GetClipboardData(CF_UNICODETEXT);
1852 if (hglb)
1853 {
1854 LPCTSTR lpstr = (LPCTSTR)GlobalLock(hglb);
1855 sClipboardText = lpstr;
1856 GlobalUnlock(hglb);
1857 }
1858 CloseClipboard();
1859
1860 if(!sClipboardText.IsEmpty())
1861 {
1862 if(sClipboardText[0] == _T('\"') && sClipboardText[sClipboardText.GetLength()-1] == _T('\"'))
1863 sClipboardText=sClipboardText.Mid(1,sClipboardText.GetLength()-2);
1864
1865 if(sClipboardText.Find( _T("http://")) == 0)
1866 return sClipboardText;
1867
1868 if(sClipboardText.Find( _T("https://")) == 0)
1869 return sClipboardText;
1870
1871 if(sClipboardText.Find( _T("git://")) == 0)
1872 return sClipboardText;
1873
1874 if(sClipboardText.Find( _T("ssh://")) == 0)
1875 return sClipboardText;
1876
1877 if(sClipboardText.GetLength()>=2)
1878 if( sClipboardText[1] == _T(':') )
1879 if( (sClipboardText[0] >= 'A' && sClipboardText[0] <= 'Z')
1880 || (sClipboardText[0] >= 'a' && sClipboardText[0] <= 'z') )
1881 return sClipboardText;
1882 }
1883
1884 return CString(_T(""));
1885 }
1886
1887 CString CAppUtils::ChooseRepository(CString *path)
1888 {
1889 CBrowseFolder browseFolder;
1890 CRegString regLastResopitory = CRegString(_T("Software\\TortoiseGit\\TortoiseProc\\LastRepo"),_T(""));
1891
1892 browseFolder.m_style = BIF_EDITBOX | BIF_NEWDIALOGSTYLE | BIF_RETURNFSANCESTORS | BIF_RETURNONLYFSDIRS;
1893 CString strCloneDirectory;
1894 if(path)
1895 strCloneDirectory=*path;
1896 else
1897 {
1898 strCloneDirectory = regLastResopitory;
1899 }
1900
1901 CString title;
1902 title.LoadString(IDS_CHOOSE_REPOSITORY);
1903
1904 browseFolder.SetInfo(title);
1905
1906 if (browseFolder.Show(NULL, strCloneDirectory) == CBrowseFolder::OK)
1907 {
1908 regLastResopitory = strCloneDirectory;
1909 return strCloneDirectory;
1910 }
1911 else
1912 {
1913 return CString();
1914 }
1915 }
1916
1917 bool CAppUtils::SendPatchMail(CTGitPathList &list,bool autoclose)
1918 {
1919 CSendMailDlg dlg;
1920
1921 dlg.m_PathList = list;
1922
1923 if(dlg.DoModal()==IDOK)
1924 {
1925 if(dlg.m_PathList.GetCount() == 0)
1926 return FALSE;
1927
1928 CGitProgressDlg progDlg;
1929
1930 theApp.m_pMainWnd = &progDlg;
1931 progDlg.SetCommand(CGitProgressDlg::GitProgress_SendMail);
1932
1933 progDlg.SetAutoClose(autoclose);
1934
1935 progDlg.SetPathList(dlg.m_PathList);
1936 //ProjectProperties props;
1937 //props.ReadPropsPathList(dlg.m_pathList);
1938 //progDlg.SetProjectProperties(props);
1939 progDlg.SetItemCount(dlg.m_PathList.GetCount());
1940
1941 DWORD flags =0;
1942 if(dlg.m_bAttachment)
1943 flags |= SENDMAIL_ATTACHMENT;
1944 if(dlg.m_bCombine)
1945 flags |= SENDMAIL_COMBINED;
1946 if(dlg.m_bUseMAPI)
1947 flags |= SENDMAIL_MAPI;
1948
1949 progDlg.SetSendMailOption(dlg.m_To,dlg.m_CC,dlg.m_Subject,flags);
1950
1951 progDlg.DoModal();
1952
1953 return true;
1954 }
1955 return false;
1956 }
1957
1958 bool CAppUtils::SendPatchMail(CString &cmd,CString &formatpatchoutput,bool autoclose)
1959 {
1960 CTGitPathList list;
1961 CString log=formatpatchoutput;
1962 int start=log.Find(cmd);
1963 if(start >=0)
1964 CString one=log.Tokenize(_T("\n"),start);
1965 else
1966 start = 0;
1967
1968 while(start>=0)
1969 {
1970 CString one=log.Tokenize(_T("\n"),start);
1971 one=one.Trim();
1972 if(one.IsEmpty() || one.Find(_T("Success")) == 0)
1973 continue;
1974 one.Replace(_T('/'),_T('\\'));
1975 CTGitPath path;
1976 path.SetFromWin(one);
1977 list.AddPath(path);
1978 }
1979 if (list.GetCount() > 0)
1980 {
1981 return SendPatchMail(list, autoclose);
1982 }
1983 else
1984 {
1985 CMessageBox::Show(NULL, IDS_ERR_NOPATCHES, IDS_APPNAME, MB_ICONINFORMATION);
1986 return true;
1987 }
1988 }
1989
1990
1991 int CAppUtils::GetLogOutputEncode(CGit *pGit)
1992 {
1993 CString cmd,output;
1994 int start=0;
1995
1996 output = pGit->GetConfigValue(_T("i18n.logOutputEncoding"));
1997 if(output.IsEmpty())
1998 {
1999 output = pGit->GetConfigValue(_T("i18n.commitencoding"));
2000 if(output.IsEmpty())
2001 return CP_UTF8;
2002
2003 int start=0;
2004 output=output.Tokenize(_T("\n"),start);
2005 return CUnicodeUtils::GetCPCode(output);
2006
2007 }
2008 else
2009 {
2010 output=output.Tokenize(_T("\n"),start);
2011 return CUnicodeUtils::GetCPCode(output);
2012 }
2013 }
2014 int CAppUtils::GetCommitTemplate(CString &temp)
2015 {
2016 CString cmd,output;
2017
2018 output = g_Git.GetConfigValue(_T("commit.template"), CP_UTF8);
2019 if( output.IsEmpty() )
2020 return -1;
2021
2022 if( output.GetLength()<1)
2023 return -1;
2024
2025 if( output[0] == _T('/'))
2026 {
2027 if(output.GetLength()>=3)
2028 if(output[2] == _T('/'))
2029 {
2030 output.GetBuffer()[0] = output[1];
2031 output.GetBuffer()[1] = _T(':');
2032 }
2033 }
2034
2035 int start=0;
2036 output=output.Tokenize(_T("\n"),start);
2037
2038 output.Replace(_T('/'),_T('\\'));
2039
2040 try
2041 {
2042 CStdioFile file(output,CFile::modeRead|CFile::typeText);
2043 CString str;
2044 while(file.ReadString(str))
2045 {
2046 temp+=str+_T("\n");
2047 }
2048
2049 }catch(...)
2050 {
2051 return -1;
2052 }
2053 return 0;
2054 }
2055 int CAppUtils::SaveCommitUnicodeFile(CString &filename, CString &message)
2056 {
2057 CFile file(filename,CFile::modeReadWrite|CFile::modeCreate );
2058 CString cmd,output;
2059 int cp=CP_UTF8;
2060
2061 output= g_Git.GetConfigValue(_T("i18n.commitencoding"));
2062 if(output.IsEmpty())
2063 cp=CP_UTF8;
2064
2065 int start=0;
2066 output=output.Tokenize(_T("\n"),start);
2067 cp=CUnicodeUtils::GetCPCode(output);
2068
2069 int len=message.GetLength();
2070
2071 std::unique_ptr<char[]> buf(new char[len * 4 + 4]);
2072 SecureZeroMemory(buf.get(), len * 4 + 4);
2073
2074 int lengthIncTerminator = WideCharToMultiByte(cp, 0, message, -1, buf.get(), len * 4, NULL, NULL);
2075
2076 file.Write(buf.get(), lengthIncTerminator - 1);
2077 file.Close();
2078 return 0;
2079 }
2080
2081 bool CAppUtils::Fetch(CString remoteName, bool allowRebase, bool autoClose)
2082 {
2083 CPullFetchDlg dlg;
2084 dlg.m_PreSelectRemote = remoteName;
2085 dlg.m_bAllowRebase = allowRebase;
2086 dlg.m_IsPull=FALSE;
2087
2088 if(dlg.DoModal()==IDOK)
2089 {
2090 if(dlg.m_bAutoLoad)
2091 {
2092 if (dlg.m_bAllRemotes)
2093 {
2094 STRING_VECTOR list;
2095 g_Git.GetRemoteList(list);
2096
2097 STRING_VECTOR::const_iterator it = list.begin();
2098 while (it != list.end())
2099 {
2100 CString remote(*it);
2101 CAppUtils::LaunchPAgent(NULL, &remote);
2102 it++;
2103 }
2104 }
2105 else
2106 CAppUtils::LaunchPAgent(NULL, &dlg.m_RemoteURL);
2107 }
2108
2109 CString url;
2110 url=dlg.m_RemoteURL;
2111 CString cmd;
2112 CString arg;
2113
2114 int ver = CAppUtils::GetMsysgitVersion();
2115
2116 if(ver >= 0x01070203) //above 1.7.0.2
2117 arg = _T("--progress ");
2118
2119 if (dlg.m_bPrune) {
2120 arg += _T("--prune ");
2121 }
2122
2123 if (dlg.m_bFetchTags == 1)
2124 {
2125 arg += _T("--tags ");
2126 }
2127 else if (dlg.m_bFetchTags == 0)
2128 {
2129 arg += _T("--no-tags ");
2130 }
2131
2132 if (dlg.m_bAllRemotes)
2133 cmd.Format(_T("git.exe fetch --all -v %s"), arg);
2134 else
2135 cmd.Format(_T("git.exe fetch -v %s \"%s\" %s"), arg, url, dlg.m_RemoteBranchName);
2136
2137 CProgressDlg progress;
2138
2139 progress.m_bAutoCloseOnSuccess = autoClose;
2140
2141 progress.m_PostCmdList.Add(CString(MAKEINTRESOURCE(IDS_MENULOG)));
2142 progress.m_PostCmdList.Add(CString(MAKEINTRESOURCE(IDS_PROC_RESET)));
2143
2144 if(!dlg.m_bRebase && !g_GitAdminDir.IsBareRepo(g_Git.m_CurrentDir))
2145 {
2146 progress.m_PostCmdList.Add(CString(MAKEINTRESOURCE(IDS_MENUREBASE)));
2147 }
2148
2149 progress.m_GitCmd=cmd;
2150 INT_PTR userResponse = progress.DoModal();
2151
2152 if (userResponse == IDC_PROGRESS_BUTTON1)
2153 {
2154 CString cmd = _T("/command:log");
2155 cmd += _T(" /path:\"") + g_Git.m_CurrentDir + _T("\"");
2156 RunTortoiseGitProc(cmd);
2157 return TRUE;
2158 }
2159 else if (userResponse == IDC_PROGRESS_BUTTON1 + 1)
2160 {
2161 CString currentBranch = g_Git.GetSymbolicRef();
2162 CString configName;
2163 configName.Format(_T("branch.%s.remote"), currentBranch);
2164 CString pullRemote = g_Git.GetConfigValue(configName);
2165
2166 //Select pull-branch from current branch
2167 configName.Format(_T("branch.%s.merge"), currentBranch);
2168 CString pullBranch = CGit::StripRefName(g_Git.GetConfigValue(configName));
2169
2170 CString defaultUpstream;
2171 if (!pullRemote.IsEmpty() && !pullBranch.IsEmpty())
2172 defaultUpstream.Format(_T("remotes/%s/%s"), pullRemote, pullBranch);
2173 GitReset(&defaultUpstream, 2);
2174 return TRUE;
2175 }
2176 else if ((userResponse == IDC_PROGRESS_BUTTON1 + 2) || (progress.m_GitStatus == 0 && dlg.m_bRebase))
2177 {
2178 while(1)
2179 {
2180 CRebaseDlg dlg;
2181 dlg.m_PostButtonTexts.Add(CString(MAKEINTRESOURCE(IDS_MENULOG)));
2182 dlg.m_PostButtonTexts.Add(CString(MAKEINTRESOURCE(IDS_MENUDESSENDMAIL)));
2183 dlg.m_PostButtonTexts.Add(CString(MAKEINTRESOURCE(IDS_MENUREBASE)));
2184 INT_PTR response = dlg.DoModal();
2185 if(response == IDOK)
2186 {
2187 return TRUE;
2188 }
2189 else if (response == IDC_REBASE_POST_BUTTON)
2190 {
2191 CString cmd = _T("/command:log");
2192 cmd += _T(" /path:\"") + g_Git.m_CurrentDir + _T("\"");
2193 RunTortoiseGitProc(cmd);
2194 return TRUE;
2195 }
2196 else if (response == IDC_REBASE_POST_BUTTON + 1)
2197 {
2198 CString cmd, out, err;
2199 cmd.Format(_T("git.exe format-patch -o \"%s\" %s..%s"),
2200 g_Git.m_CurrentDir,
2201 g_Git.FixBranchName(dlg.m_Upstream),
2202 g_Git.FixBranchName(dlg.m_Branch));
2203 if (g_Git.Run(cmd, &out, &err, CP_UTF8))
2204 {
2205 CMessageBox::Show(NULL, out + L"\n" + err, _T("TortoiseGit"), MB_OK|MB_ICONERROR);
2206 return FALSE;
2207 }
2208
2209 CAppUtils::SendPatchMail(cmd,out);
2210 return TRUE;
2211 }
2212 else if (response == IDC_REBASE_POST_BUTTON + 2)
2213 continue;
2214 else if(response == IDCANCEL)
2215 return FALSE;
2216 }
2217 return TRUE;
2218 }
2219 else if (userResponse != IDCANCEL)
2220 return TRUE;
2221 }
2222 return FALSE;
2223 }
2224
2225 bool CAppUtils::Push(CString selectLocalBranch, bool autoClose)
2226 {
2227 CPushDlg dlg;
2228 dlg.m_BranchSourceName = selectLocalBranch;
2229 CString error;
2230 DWORD exitcode = 0xFFFFFFFF;
2231 CTGitPathList list;
2232 list.AddPath(CTGitPath(g_Git.m_CurrentDir));
2233 if (CHooks::Instance().PrePush(list,exitcode, error))
2234 {
2235 if (exitcode)
2236 {
2237 CString temp;
2238 temp.Format(IDS_ERR_HOOKFAILED, (LPCTSTR)error);
2239 //ReportError(temp);
2240 CMessageBox::Show(NULL,temp,_T("TortoiseGit"),MB_OK|MB_ICONERROR);
2241 return false;
2242 }
2243 }
2244
2245 if(dlg.DoModal()==IDOK)
2246 {
2247 CString arg;
2248
2249 if(dlg.m_bPack)
2250 arg += _T("--thin ");
2251 if(dlg.m_bTags && !dlg.m_bPushAllBranches)
2252 arg += _T("--tags ");
2253 if(dlg.m_bForce)
2254 arg += _T("--force ");
2255 if (dlg.m_bSetUpstream)
2256 arg += _T("--set-upstream ");
2257 if (dlg.m_RecurseSubmodules == 1)
2258 arg += _T("--recurse-submodules=check ");
2259 if (dlg.m_RecurseSubmodules == 2)
2260 arg += _T("--recurse-submodules=on-demand ");
2261
2262 int ver = CAppUtils::GetMsysgitVersion();
2263
2264 if(ver >= 0x01070203) //above 1.7.0.2
2265 arg += _T("--progress ");
2266
2267 CProgressDlg progress;
2268 progress.m_bAutoCloseOnSuccess=autoClose;
2269
2270 STRING_VECTOR remotesList;
2271 if (dlg.m_bPushAllRemotes)
2272 g_Git.GetRemoteList(remotesList);
2273 else
2274 remotesList.push_back(dlg.m_URL);
2275
2276 for (unsigned int i = 0; i < remotesList.size(); i++)
2277 {
2278 if (dlg.m_bAutoLoad)
2279 CAppUtils::LaunchPAgent(NULL, &remotesList[i]);
2280
2281 CString cmd;
2282 if (dlg.m_bPushAllBranches)
2283 {
2284 cmd.Format(_T("git.exe push --all %s \"%s\""),
2285 arg,
2286 remotesList[i]);
2287 }
2288 else
2289 {
2290 cmd.Format(_T("git.exe push %s \"%s\" %s"),
2291 arg,
2292 remotesList[i],
2293 dlg.m_BranchSourceName);
2294 if (!dlg.m_BranchRemoteName.IsEmpty())
2295 {
2296 cmd += _T(":") + dlg.m_BranchRemoteName;
2297 }
2298 }
2299 progress.m_GitCmdList.push_back(cmd);
2300 }
2301
2302 progress.m_PostCmdList.Add(CString(MAKEINTRESOURCE(IDS_PROC_REQUESTPULL)));
2303 progress.m_PostCmdList.Add(CString(MAKEINTRESOURCE(IDS_MENUPUSH)));
2304 INT_PTR ret = progress.DoModal();
2305
2306 if(!progress.m_GitStatus)
2307 {
2308 if (CHooks::Instance().PostPush(list,exitcode, error))
2309 {
2310 if (exitcode)
2311 {
2312 CString temp;
2313 temp.Format(IDS_ERR_HOOKFAILED, (LPCTSTR)error);
2314 //ReportError(temp);
2315 CMessageBox::Show(NULL,temp,_T("TortoiseGit"),MB_OK|MB_ICONERROR);
2316 return false;
2317 }
2318 }
2319 if(ret == IDC_PROGRESS_BUTTON1)
2320 {
2321 RequestPull(dlg.m_BranchRemoteName);
2322 }
2323 else if(ret == IDC_PROGRESS_BUTTON1 + 1)
2324 {
2325 Push();
2326 }
2327 return TRUE;
2328 }
2329
2330 }
2331 return FALSE;
2332 }
2333
2334 bool CAppUtils::RequestPull(CString endrevision, CString repositoryUrl)
2335 {
2336 CRequestPullDlg dlg;
2337 dlg.m_RepositoryURL = repositoryUrl;
2338 dlg.m_EndRevision = endrevision;
2339 if (dlg.DoModal()==IDOK)
2340 {
2341 CString cmd;
2342 cmd.Format(_T("git.exe request-pull %s \"%s\" %s"), dlg.m_StartRevision, dlg.m_RepositoryURL, dlg.m_EndRevision);
2343
2344 CSysProgressDlg sysProgressDlg;
2345 sysProgressDlg.SetTitle(CString(MAKEINTRESOURCE(IDS_APPNAME)));
2346 sysProgressDlg.SetLine(1, CString(MAKEINTRESOURCE(IDS_PROC_CREATINGPULLREUQEST)));
2347 sysProgressDlg.SetLine(2, CString(MAKEINTRESOURCE(IDS_PROGRESSWAIT)));
2348 sysProgressDlg.SetShowProgressBar(false);
2349 sysProgressDlg.ShowModeless((HWND)NULL, true);
2350
2351 CString tempFileName = GetTempFile();
2352 if (g_Git.RunLogFile(cmd, tempFileName))
2353 {
2354 CMessageBox::Show(NULL, IDS_ERR_PULLREUQESTFAILED, IDS_APPNAME, MB_OK);
2355 return false;
2356 }
2357
2358 if (sysProgressDlg.HasUserCancelled())
2359 {
2360 CMessageBox::Show(NULL, IDS_SVN_USERCANCELLED, IDS_APPNAME, MB_OK);
2361 ::DeleteFile(tempFileName);
2362 return false;
2363 }
2364
2365 sysProgressDlg.Stop();
2366
2367 CAppUtils::LaunchAlternativeEditor(tempFileName);
2368 }
2369 return true;
2370 }
2371
2372 bool CAppUtils::CreateMultipleDirectory(const CString& szPath)
2373 {
2374 CString strDir(szPath);
2375 if (strDir.GetAt(strDir.GetLength()-1)!=_T('\\'))
2376 {
2377 strDir.AppendChar(_T('\\'));
2378 }
2379 std::vector<CString> vPath;
2380 CString strTemp;
2381 bool bSuccess = false;
2382
2383 for (int i=0;i<strDir.GetLength();++i)
2384 {
2385 if (strDir.GetAt(i) != _T('\\'))
2386 {
2387 strTemp.AppendChar(strDir.GetAt(i));
2388 }
2389 else
2390 {
2391 vPath.push_back(strTemp);
2392 strTemp.AppendChar(_T('\\'));
2393 }
2394 }
2395
2396 std::vector<CString>::const_iterator vIter;
2397 for (vIter = vPath.begin(); vIter != vPath.end(); vIter++)
2398 {
2399 bSuccess = CreateDirectory(*vIter, NULL) ? true : false;
2400 }
2401
2402 return bSuccess;
2403 }
2404
2405 void CAppUtils::RemoveTrailSlash(CString &path)
2406 {
2407 if(path.IsEmpty())
2408 return ;
2409
2410 while(path[path.GetLength()-1] == _T('\\') || path[path.GetLength()-1] == _T('/' ) )
2411 {
2412 path=path.Left(path.GetLength()-1);
2413 if(path.IsEmpty())
2414 return;
2415 }
2416 }
2417
2418 bool CAppUtils::CheckUserData()
2419 {
2420 while(g_Git.GetUserName().IsEmpty() || g_Git.GetUserEmail().IsEmpty())
2421 {
2422 if(CMessageBox::Show(NULL, IDS_PROC_NOUSERDATA, IDS_APPNAME, MB_YESNO| MB_ICONERROR) == IDYES)
2423 {
2424 CTGitPath path(g_Git.m_CurrentDir);
2425 CSettings dlg(IDS_PROC_SETTINGS_TITLE,&path);
2426 dlg.SetTreeViewMode(TRUE, TRUE, TRUE);
2427 dlg.SetTreeWidth(220);
2428 dlg.m_DefaultPage = _T("gitconfig");
2429
2430 dlg.DoModal();
2431 dlg.HandleRestart();
2432
2433 }
2434 else
2435 return false;
2436 }
2437
2438 return true;
2439 }
2440
2441 BOOL CAppUtils::Commit(CString bugid,BOOL bWholeProject,CString &sLogMsg,
2442 CTGitPathList &pathList,
2443 CTGitPathList &selectedList,
2444 bool bSelectFilesForCommit,
2445 bool autoClose)
2446 {
2447 bool bFailed = true;
2448
2449 if (!CheckUserData())
2450 return false;
2451
2452 while (bFailed)
2453 {
2454 bFailed = false;
2455 CCommitDlg dlg;
2456 dlg.m_sBugID = bugid;
2457
2458 dlg.m_bWholeProject = bWholeProject;
2459
2460 dlg.m_sLogMessage = sLogMsg;
2461 dlg.m_pathList = pathList;
2462 dlg.m_checkedPathList = selectedList;
2463 dlg.m_bSelectFilesForCommit = bSelectFilesForCommit;
2464 dlg.m_bAutoClose = autoClose;
2465 if (dlg.DoModal() == IDOK)
2466 {
2467 if (dlg.m_pathList.GetCount()==0)
2468 return false;
2469 // if the user hasn't changed the list of selected items
2470 // we don't use that list. Because if we would use the list
2471 // of pre-checked items, the dialog would show different
2472 // checked items on the next startup: it would only try
2473 // to check the parent folder (which might not even show)
2474 // instead, we simply use an empty list and let the
2475 // default checking do its job.
2476 if (!dlg.m_pathList.IsEqual(pathList))
2477 selectedList = dlg.m_pathList;
2478 pathList = dlg.m_updatedPathList;
2479 sLogMsg = dlg.m_sLogMessage;
2480 bSelectFilesForCommit = true;
2481
2482 if( dlg.m_bPushAfterCommit )
2483 {
2484 switch(dlg.m_PostCmd)
2485 {
2486 case GIT_POST_CMD_DCOMMIT:
2487 CAppUtils::SVNDCommit();
2488 break;
2489 default:
2490 CAppUtils::Push();
2491 }
2492 }
2493 else if (dlg.m_bCreateTagAfterCommit)
2494 {
2495 CAppUtils::CreateBranchTag(TRUE);
2496 }
2497
2498 // CGitProgressDlg progDlg;
2499 // progDlg.SetChangeList(dlg.m_sChangeList, !!dlg.m_bKeepChangeList);
2500 // if (parser.HasVal(_T("closeonend")))
2501 // progDlg.SetAutoClose(parser.GetLongVal(_T("closeonend")));
2502 // progDlg.SetCommand(CGitProgressDlg::GitProgress_Commit);
2503 // progDlg.SetOptions(dlg.m_bKeepLocks ? ProgOptKeeplocks : ProgOptNone);
2504 // progDlg.SetPathList(dlg.m_pathList);
2505 // progDlg.SetCommitMessage(dlg.m_sLogMessage);
2506 // progDlg.SetDepth(dlg.m_bRecursive ? Git_depth_infinity : svn_depth_empty);
2507 // progDlg.SetSelectedList(dlg.m_selectedPathList);
2508 // progDlg.SetItemCount(dlg.m_itemsCount);
2509 // progDlg.SetBugTraqProvider(dlg.m_BugTraqProvider);
2510 // progDlg.DoModal();
2511 // CRegDWORD err = CRegDWORD(_T("Software\\TortoiseGit\\ErrorOccurred"), FALSE);
2512 // err = (DWORD)progDlg.DidErrorsOccur();
2513 // bFailed = progDlg.DidErrorsOccur();
2514 // bRet = progDlg.DidErrorsOccur();
2515 // CRegDWORD bFailRepeat = CRegDWORD(_T("Software\\TortoiseGit\\CommitReopen"), FALSE);
2516 // if (DWORD(bFailRepeat)==0)
2517 // bFailed = false; // do not repeat if the user chose not to in the settings.
2518 }
2519 }
2520 return true;
2521 }
2522
2523
2524 BOOL CAppUtils::SVNDCommit()
2525 {
2526 CSVNDCommitDlg dcommitdlg;
2527 CString gitSetting = g_Git.GetConfigValue(_T("svn.rmdir"));
2528 if (gitSetting == _T("")) {
2529 if (dcommitdlg.DoModal() != IDOK)
2530 {
2531 return false;
2532 }
2533 else
2534 {
2535 if (dcommitdlg.m_remember)
2536 {
2537 if (dcommitdlg.m_rmdir)
2538 {
2539 gitSetting = _T("true");
2540 }
2541 else
2542 {
2543 gitSetting = _T("false");
2544 }
2545 if(g_Git.SetConfigValue(_T("svn.rmdir"),gitSetting))
2546 {
2547 CString msg;
2548 msg.Format(IDS_PROC_SAVECONFIGFAILED, _T("svn.rmdir"), gitSetting);
2549 CMessageBox::Show(NULL, msg, _T("TortoiseGit"), MB_OK | MB_ICONERROR);
2550 }
2551 }
2552 }
2553 }
2554
2555 BOOL IsStash = false;
2556 if(!g_Git.CheckCleanWorkTree())
2557 {
2558 if (CMessageBox::Show(NULL, IDS_ERROR_NOCLEAN_STASH, IDS_APPNAME, 1, IDI_QUESTION, IDS_STASHBUTTON, IDS_ABORTBUTTON) == 1)
2559 {
2560 CSysProgressDlg sysProgressDlg;
2561 sysProgressDlg.SetTitle(CString(MAKEINTRESOURCE(IDS_APPNAME)));
2562 sysProgressDlg.SetLine(1, CString(MAKEINTRESOURCE(IDS_PROC_STASHRUNNING)));
2563 sysProgressDlg.SetLine(2, CString(MAKEINTRESOURCE(IDS_PROGRESSWAIT)));
2564 sysProgressDlg.SetShowProgressBar(false);
2565 sysProgressDlg.SetCancelMsg(IDS_PROGRS_INFOFAILED);
2566 sysProgressDlg.ShowModeless((HWND)NULL, true);
2567
2568 CString cmd,out;
2569 cmd=_T("git.exe stash");
2570 if (g_Git.Run(cmd, &out, CP_UTF8))
2571 {
2572 sysProgressDlg.Stop();
2573 CMessageBox::Show(NULL,out,_T("TortoiseGit"),MB_OK);
2574 return false;
2575 }
2576 sysProgressDlg.Stop();
2577
2578 IsStash =true;
2579 }
2580 else
2581 {
2582 return false;
2583 }
2584 }
2585
2586 CProgressDlg progress;
2587 if (dcommitdlg.m_rmdir)
2588 {
2589 progress.m_GitCmd=_T("git.exe svn dcommit --rmdir");
2590 }
2591 else
2592 {
2593 progress.m_GitCmd=_T("git.exe svn dcommit");
2594 }
2595 if(progress.DoModal()==IDOK && progress.m_GitStatus == 0)
2596 {
2597 if( IsStash)
2598 {
2599 if(CMessageBox::Show(NULL,IDS_DCOMMIT_STASH_POP,IDS_APPNAME,MB_YESNO|MB_ICONINFORMATION)==IDYES)
2600 {
2601 CSysProgressDlg sysProgressDlg;
2602 sysProgressDlg.SetTitle(CString(MAKEINTRESOURCE(IDS_APPNAME)));
2603 sysProgressDlg.SetLine(1, CString(MAKEINTRESOURCE(IDS_PROC_STASHRUNNING)));
2604 sysProgressDlg.SetLine(2, CString(MAKEINTRESOURCE(IDS_PROGRESSWAIT)));
2605 sysProgressDlg.SetShowProgressBar(false);
2606 sysProgressDlg.SetCancelMsg(IDS_PROGRS_INFOFAILED);
2607 sysProgressDlg.ShowModeless((HWND)NULL, true);
2608
2609 CString cmd,out;
2610 cmd=_T("git.exe stash pop");
2611 if (g_Git.Run(cmd, &out, CP_UTF8))
2612 {
2613 sysProgressDlg.Stop();
2614 CMessageBox::Show(NULL,out,_T("TortoiseGit"),MB_OK);
2615 return false;
2616 }
2617 sysProgressDlg.Stop();
2618 }
2619 else
2620 {
2621 return false;
2622 }
2623 }
2624 return TRUE;
2625 }
2626 return FALSE;
2627 }
2628
2629 static void MergeCallback(CProgressDlg *dlg, void *caller, int result)
2630 {
2631 UNREFERENCED_PARAMETER(caller);
2632
2633 if (result)
2634 {
2635 dlg->m_PostCmdList.RemoveAll();
2636
2637 CTGitPathList list;
2638 if (!g_Git.ListConflictFile(list) && list.GetCount() > 0)
2639 {
2640 // there are conflict files
2641 dlg->m_PostCmdList.Add(CString(MAKEINTRESOURCE(IDS_PROGRS_CMD_RESOLVE)));
2642 }
2643 }
2644 }
2645
2646 BOOL CAppUtils::Merge(CString *commit)
2647 {
2648 if (!CheckUserData())
2649 return FALSE;
2650
2651 CMergeDlg dlg;
2652 if(commit)
2653 dlg.m_initialRefName = *commit;
2654
2655 if(dlg.DoModal()==IDOK)
2656 {
2657 CString cmd;
2658 CString noff;
2659 CString squash;
2660 CString nocommit;
2661 CString msg;
2662
2663 if(dlg.m_bNoFF)
2664 noff=_T("--no-ff");
2665
2666 if(dlg.m_bSquash)
2667 squash=_T("--squash");
2668
2669 if(dlg.m_bNoCommit)
2670 nocommit=_T("--no-commit");
2671
2672 if(!dlg.m_strLogMesage.IsEmpty())
2673 {
2674 CString logmsg = dlg.m_strLogMesage;
2675 logmsg.Replace(_T("\""), _T("\\\""));
2676 msg += _T("-m \"") + logmsg + _T("\"");
2677 }
2678 cmd.Format(_T("git.exe merge %s %s %s %s %s"),
2679 msg,
2680 noff,
2681 squash,
2682 nocommit,
2683 g_Git.FixBranchName(dlg.m_VersionName));
2684
2685 CProgressDlg Prodlg;
2686 Prodlg.m_GitCmd = cmd;
2687
2688 if (dlg.m_bNoCommit)
2689 Prodlg.m_PostCmdList.Add(CString(MAKEINTRESOURCE(IDS_MENUCOMMIT)));
2690 else if (dlg.m_bIsBranch)
2691 Prodlg.m_PostCmdList.Add(CString(MAKEINTRESOURCE(IDS_PROC_REMOVEBRANCH)));
2692
2693 Prodlg.m_PostCmdCallback = MergeCallback;
2694
2695 INT_PTR ret = Prodlg.DoModal();
2696 if (Prodlg.m_GitStatus != 0 && ret == IDC_PROGRESS_BUTTON1)
2697 {
2698 CTGitPathList pathlist;
2699 CTGitPathList selectedlist;
2700 pathlist.AddPath(g_Git.m_CurrentDir);
2701 bool bSelectFilesForCommit = !!DWORD(CRegStdDWORD(_T("Software\\TortoiseGit\\SelectFilesForCommit"), TRUE));
2702 CString str;
2703 CAppUtils::Commit(CString(), false, str, pathlist, selectedlist, bSelectFilesForCommit);
2704 }
2705 else if (ret == IDC_PROGRESS_BUTTON1)
2706 {
2707 if (dlg.m_bNoCommit)
2708 {
2709 CString sLogMsg;
2710 CTGitPathList pathList;
2711 CTGitPathList selectedList;
2712 return Commit(_T(""), TRUE, sLogMsg, pathList, selectedList, true);
2713 }
2714 else if (dlg.m_bIsBranch)
2715 {
2716 CString msg;
2717 msg.Format(IDS_PROC_DELETEBRANCHTAG, dlg.m_VersionName);
2718 if (CMessageBox::Show(NULL, msg, _T("TortoiseGit"), 2, IDI_QUESTION, CString(MAKEINTRESOURCE(IDS_DELETEBUTTON)), CString(MAKEINTRESOURCE(IDS_ABORTBUTTON))) == 1)
2719 {
2720 CString cmd, out;
2721 cmd.Format(_T("git.exe branch -D -- %s"), dlg.m_VersionName);
2722 if (g_Git.Run(cmd, &out, CP_UTF8))
2723 MessageBox(NULL, out, _T("TortoiseGit"), MB_OK);
2724 }
2725 }
2726 }
2727
2728 return !Prodlg.m_GitStatus;
2729 }
2730 return false;
2731 }
2732
2733 void CAppUtils::EditNote(GitRev *rev)
2734 {
2735 if (!CheckUserData())
2736 return;
2737
2738 CInputDlg dlg;
2739 dlg.m_sHintText = CString(MAKEINTRESOURCE(IDS_PROGS_TITLE_EDITNOTES));
2740 dlg.m_sInputText = rev->m_Notes;
2741 dlg.m_sTitle = CString(MAKEINTRESOURCE(IDS_PROGS_TITLE_EDITNOTES));
2742 //dlg.m_pProjectProperties = &m_ProjectProperties;
2743 dlg.m_bUseLogWidth = true;
2744 if(dlg.DoModal() == IDOK)
2745 {
2746 CString cmd,output;
2747 cmd=_T("notes add -f -F \"");
2748
2749 CString tempfile=::GetTempFile();
2750 CAppUtils::SaveCommitUnicodeFile(tempfile,dlg.m_sInputText);
2751 cmd += tempfile;
2752 cmd += _T("\" ");
2753 cmd += rev->m_CommitHash.ToString();
2754
2755 try
2756 {
2757 if (git_run_cmd("notes", CUnicodeUtils::GetMulti(cmd, CP_UTF8).GetBuffer()))
2758 {
2759 CMessageBox::Show(NULL, IDS_PROC_FAILEDSAVINGNOTES, IDS_APPNAME, MB_OK | MB_ICONERROR);
2760
2761 }
2762 else
2763 {
2764 rev->m_Notes = dlg.m_sInputText;
2765 }
2766 }catch(...)
2767 {
2768 CMessageBox::Show(NULL, IDS_PROC_FAILEDSAVINGNOTES, IDS_APPNAME, MB_OK | MB_ICONERROR);
2769 }
2770 CFile::Remove(tempfile);
2771
2772 }
2773 }
2774
2775 int CAppUtils::GetMsysgitVersion(CString *versionstr)
2776 {
2777 CString cmd;
2778 CString versiondebug;
2779 CString version;
2780
2781 CRegDWORD regTime = CRegDWORD(_T("Software\\TortoiseGit\\git_file_time"));
2782 CRegDWORD regVersion = CRegDWORD(_T("Software\\TortoiseGit\\git_cached_version"));
2783
2784 CString gitpath = CGit::ms_LastMsysGitDir+_T("\\git.exe");
2785
2786 __int64 time=0;
2787 if(!g_Git.GetFileModifyTime(gitpath, &time) && !versionstr)
2788 {
2789 if((DWORD)time == regTime)
2790 {
2791 return regVersion;
2792 }
2793 }
2794
2795 if(versionstr)
2796 version = *versionstr;
2797 else
2798 {
2799 CString err;
2800 cmd = _T("git.exe --version");
2801 if (g_Git.Run(cmd, &version, &err, CP_UTF8))
2802 {
2803 CMessageBox::Show(NULL, _T("git have not installed (") + err + _T(")"), _T("TortoiseGit"), MB_OK|MB_ICONERROR);
2804 return false;
2805 }
2806 }
2807
2808 int start=0;
2809 int ver = 0;
2810
2811 versiondebug = version;
2812
2813 try
2814 {
2815 CString str=version.Tokenize(_T("."), start);
2816 int space = str.ReverseFind(_T(' '));
2817 str = str.Mid(space+1,start);
2818 ver = _ttol(str);
2819 ver <<=24;
2820
2821 version = version.Mid(start);
2822 start = 0;
2823
2824 str = version.Tokenize(_T("."), start);
2825
2826 ver |= (_ttol(str) & 0xFF) << 16;
2827
2828 str = version.Tokenize(_T("."), start);
2829 ver |= (_ttol(str) & 0xFF) << 8;
2830
2831 str = version.Tokenize(_T("."), start);
2832 ver |= (_ttol(str) & 0xFF);
2833 }
2834 catch(...)
2835 {
2836 if (!ver)
2837 {
2838 CMessageBox::Show(NULL, _T("Could not parse git.exe version number: \"") + versiondebug + _T("\""), _T("TortoiseGit"), MB_OK | MB_ICONERROR);
2839 return false;
2840 }
2841 }
2842
2843 regTime = time&0xFFFFFFFF;
2844 regVersion = ver;
2845
2846 return ver;
2847 }
2848
2849 void CAppUtils::MarkWindowAsUnpinnable(HWND hWnd)
2850 {
2851 typedef HRESULT (WINAPI *SHGPSFW) (HWND hwnd,REFIID riid,void** ppv);
2852
2853 CAutoLibrary hShell = AtlLoadSystemLibraryUsingFullPath(_T("Shell32.dll"));
2854
2855 if (hShell.IsValid()) {
2856 SHGPSFW pfnSHGPSFW = (SHGPSFW)::GetProcAddress(hShell, "SHGetPropertyStoreForWindow");
2857 if (pfnSHGPSFW) {
2858 IPropertyStore *pps;
2859 HRESULT hr = pfnSHGPSFW(hWnd, IID_PPV_ARGS(&pps));
2860 if (SUCCEEDED(hr)) {
2861 PROPVARIANT var;
2862 var.vt = VT_BOOL;
2863 var.boolVal = VARIANT_TRUE;
2864 hr = pps->SetValue(PKEY_AppUserModel_PreventPinning, var);
2865 pps->Release();
2866 }
2867 }
2868 }
2869 }
2870
2871 void CAppUtils::SetWindowTitle(HWND hWnd, const CString& urlorpath, const CString& dialogname)
2872 {
2873 ASSERT(dialogname.GetLength() < 70);
2874 ASSERT(urlorpath.GetLength() < MAX_PATH);
2875 WCHAR pathbuf[MAX_PATH] = {0};
2876
2877 PathCompactPathEx(pathbuf, urlorpath, 70 - dialogname.GetLength(), 0);
2878
2879 wcscat_s(pathbuf, L" - ");
2880 wcscat_s(pathbuf, dialogname);
2881 wcscat_s(pathbuf, L" - ");
2882 wcscat_s(pathbuf, CString(MAKEINTRESOURCE(IDS_APPNAME)));
2883 SetWindowText(hWnd, pathbuf);
2884 }
2885
2886 bool CAppUtils::BisectStart(CString lastGood, CString firstBad, bool autoClose)
2887 {
2888 if (!g_Git.CheckCleanWorkTree())
2889 {
2890 if (CMessageBox::Show(NULL, IDS_ERROR_NOCLEAN_STASH, IDS_APPNAME, 1, IDI_QUESTION, IDS_STASHBUTTON, IDS_ABORTBUTTON) == 1)
2891 {
2892 CSysProgressDlg sysProgressDlg;
2893 sysProgressDlg.SetTitle(CString(MAKEINTRESOURCE(IDS_APPNAME)));
2894 sysProgressDlg.SetLine(1, CString(MAKEINTRESOURCE(IDS_PROC_STASHRUNNING)));
2895 sysProgressDlg.SetLine(2, CString(MAKEINTRESOURCE(IDS_PROGRESSWAIT)));
2896 sysProgressDlg.SetShowProgressBar(false);
2897 sysProgressDlg.SetCancelMsg(IDS_PROGRS_INFOFAILED);
2898 sysProgressDlg.ShowModeless((HWND)NULL, true);
2899
2900 CString cmd, out;
2901 cmd = _T("git.exe stash");
2902 if (g_Git.Run(cmd, &out, CP_UTF8))
2903 {
2904 sysProgressDlg.Stop();
2905 CMessageBox::Show(NULL, out, _T("TortoiseGit"), MB_OK);
2906 return false;
2907 }
2908 sysProgressDlg.Stop();
2909 }
2910 else
2911 return false;
2912 }
2913
2914 CBisectStartDlg bisectStartDlg;
2915
2916 if (!lastGood.IsEmpty())
2917 bisectStartDlg.m_sLastGood = lastGood;
2918 if (!firstBad.IsEmpty())
2919 bisectStartDlg.m_sFirstBad = firstBad;
2920
2921 if (bisectStartDlg.DoModal() == IDOK)
2922 {
2923 CProgressDlg progress;
2924 theApp.m_pMainWnd = &progress;
2925 progress.m_bAutoCloseOnSuccess = autoClose;
2926 progress.m_GitCmdList.push_back(_T("git.exe bisect start"));
2927 progress.m_GitCmdList.push_back(_T("git.exe bisect good ") + bisectStartDlg.m_LastGoodRevision);
2928 progress.m_GitCmdList.push_back(_T("git.exe bisect bad ") + bisectStartDlg.m_FirstBadRevision);
2929
2930 CTGitPath path(g_Git.m_CurrentDir);
2931
2932 if (path.HasSubmodules())
2933 progress.m_PostCmdList.Add(CString(MAKEINTRESOURCE(IDS_PROC_SUBMODULESUPDATE)));
2934
2935 INT_PTR ret = progress.DoModal();
2936 if (path.HasSubmodules() && ret == IDC_PROGRESS_BUTTON1)
2937 {
2938 CString sCmd;
2939 sCmd.Format(_T("/command:subupdate /bkpath:\"%s\""), g_Git.m_CurrentDir);
2940
2941 CAppUtils::RunTortoiseGitProc(sCmd);
2942 return true;
2943 }
2944 else if (ret == IDOK)
2945 return true;
2946 }
2947
2948 return false;
2949 }
Windows Explorer Extension to Operate Git