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