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