?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Fixed issue #2469: Support reviewing merge commits (git show merge-commit)
[TortoiseGit.git] / src / TortoiseProc / GitLogListAction.cpp
blob7f5049a9f684ffca459d930f823f5fe13fa0ef88
1 // TortoiseGit - a Windows shell extension for easy version control
2
3 // Copyright (C) 2008-2015 - TortoiseGit
4 // Copyright (C) 2005-2007 Marco Costalba
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 // GitLogList.cpp : implementation file
21 //
22 #include "stdafx.h"
23 #include "TortoiseProc.h"
24 #include "GitLogList.h"
25 #include "GitRev.h"
26 #include "IconMenu.h"
27 #include "cursor.h"
28 #include "GitProgressDlg.h"
29 #include "ProgressDlg.h"
30 #include "SysProgressDlg.h"
31 #include "LogDlg.h"
32 #include "MessageBox.h"
33 #include "registry.h"
34 #include "AppUtils.h"
35 #include "StringUtils.h"
36 #include "UnicodeUtils.h"
37 #include "TempFile.h"
38 #include "FileDiffDlg.h"
39 #include "CommitDlg.h"
40 #include "RebaseDlg.h"
41 #include "GitDiff.h"
42 #include "../TGitCache/CacheInterface.h"
43
44 IMPLEMENT_DYNAMIC(CGitLogList, CHintListCtrl)
45
46 int CGitLogList::RevertSelectedCommits(int parent)
47 {
48 CSysProgressDlg progress;
49 int ret = -1;
50
51 #if 0
52 if(!g_Git.CheckCleanWorkTree())
53 {
54 CMessageBox::Show(NULL, IDS_PROC_NOCLEAN, IDS_APPNAME, MB_OK);
55
56 }
57 #endif
58
59 if (this->GetSelectedCount() > 1)
60 {
61 progress.SetTitle(CString(MAKEINTRESOURCE(IDS_PROGS_TITLE_REVERTCOMMIT)));
62 progress.SetAnimation(IDR_MOVEANI);
63 progress.SetTime(true);
64 progress.ShowModeless(this);
65 }
66
67 CBlockCacheForPath cacheBlock(g_Git.m_CurrentDir);
68
69 POSITION pos = GetFirstSelectedItemPosition();
70 int i=0;
71 while(pos)
72 {
73 int index = GetNextSelectedItem(pos);
74 GitRev * r1 = reinterpret_cast<GitRev*>(m_arShownList.GetAt(index));
75
76 if (progress.IsVisible())
77 {
78 progress.FormatNonPathLine(1, IDS_PROC_REVERTCOMMIT, r1->m_CommitHash.ToString());
79 progress.FormatNonPathLine(2, _T("%s"), r1->GetSubject());
80 progress.SetProgress(i, this->GetSelectedCount());
81 }
82 ++i;
83
84 if(r1->m_CommitHash.IsEmpty())
85 continue;
86
87 if (g_Git.GitRevert(parent, r1->m_CommitHash))
88 {
89 CString str;
90 str.LoadString(IDS_SVNACTION_FAILEDREVERT);
91 str = g_Git.GetGitLastErr(str, CGit::GIT_CMD_REVERT);
92 if( GetSelectedCount() == 1)
93 CMessageBox::Show(NULL, str, _T("TortoiseGit"), MB_OK | MB_ICONERROR);
94 else
95 {
96 if(CMessageBox::Show(NULL, str, _T("TortoiseGit"),2 , IDI_ERROR, CString(MAKEINTRESOURCE(IDS_SKIPBUTTON)), CString(MAKEINTRESOURCE(IDS_ABORTBUTTON))) == 2)
97 {
98 return ret;
99 }
100 }
101 }
102 else
103 {
104 ret =0;
105 }
106
107 if (progress.HasUserCancelled())
108 break;
109 }
110 return ret;
111 }
112 int CGitLogList::CherryPickFrom(CString from, CString to)
113 {
114 CLogDataVector logs(&m_LogCache);
115 CString range;
116 range.Format(_T("%s..%s"), from, to);
117 if (logs.ParserFromLog(nullptr, -1, 0, &range))
118 return -1;
119
120 if (logs.empty())
121 return 0;
122
123 CSysProgressDlg progress;
124 progress.SetTitle(CString(MAKEINTRESOURCE(IDS_PROGS_TITLE_CHERRYPICK)));
125 progress.SetAnimation(IDR_MOVEANI);
126 progress.SetTime(true);
127 progress.ShowModeless(this);
128
129 CBlockCacheForPath cacheBlock(g_Git.m_CurrentDir);
130
131 for (int i = (int)logs.size() - 1; i >= 0; i--)
132 {
133 if (progress.IsVisible())
134 {
135 progress.FormatNonPathLine(1, IDS_PROC_PICK, logs.GetGitRevAt(i).m_CommitHash.ToString());
136 progress.FormatNonPathLine(2, _T("%s"), logs.GetGitRevAt(i).GetSubject());
137 progress.SetProgress64(logs.size() - i, logs.size());
138 }
139 if (progress.HasUserCancelled())
140 {
141 throw std::exception(CUnicodeUtils::GetUTF8(CString(MAKEINTRESOURCE(IDS_SVN_USERCANCELLED))));
142 }
143 CString cmd,out;
144 cmd.Format(_T("git.exe cherry-pick %s"),logs.GetGitRevAt(i).m_CommitHash.ToString());
145 out.Empty();
146 if(g_Git.Run(cmd,&out,CP_UTF8))
147 {
148 throw std::exception(CUnicodeUtils::GetUTF8(CString(MAKEINTRESOURCE(IDS_PROC_CHERRYPICKFAILED)) + _T(":\r\n\r\n") + out));
149 }
150 }
151
152 return 0;
153 }
154
155 void CGitLogList::ContextMenuAction(int cmd,int FirstSelect, int LastSelect, CMenu *popmenu)
156 {
157 POSITION pos = GetFirstSelectedItemPosition();
158 int indexNext = GetNextSelectedItem(pos);
159 if (indexNext < 0)
160 return;
161
162 GitRevLoglist* pSelLogEntry = reinterpret_cast<GitRevLoglist*>(m_arShownList.GetAt(indexNext));
163
164 theApp.DoWaitCursor(1);
165 switch (cmd&0xFFFF)
166 {
167 case ID_COMMIT:
168 {
169 CTGitPathList pathlist;
170 CTGitPathList selectedlist;
171 pathlist.AddPath(this->m_Path);
172 bool bSelectFilesForCommit = !!DWORD(CRegStdDWORD(_T("Software\\TortoiseGit\\SelectFilesForCommit"), TRUE));
173 CString str;
174 CAppUtils::Commit(CString(),false,str,
175 pathlist,selectedlist,bSelectFilesForCommit);
176 //this->Refresh();
177 this->GetParent()->PostMessage(WM_COMMAND,ID_LOGDLG_REFRESH,0);
178 }
179 break;
180 case ID_MERGE_ABORT:
181 {
182 if (CAppUtils::MergeAbort())
183 this->GetParent()->PostMessage(WM_COMMAND,ID_LOGDLG_REFRESH, 0);
184 }
185 break;
186 case ID_GNUDIFF1: // compare with WC, unified
187 {
188 GitRev * r1 = reinterpret_cast<GitRev*>(m_arShownList.GetAt(FirstSelect));
189 bool bMerge = false, bCombine = false;
190 CString hash2;
191 if(!r1->m_CommitHash.IsEmpty())
192 {
193 CString merge;
194 cmd >>= 16;
195 if( (cmd&0xFFFF) == 0xFFFF)
196 bMerge = true;
197 else if((cmd&0xFFFF) == 0xFFFE)
198 bCombine = true;
199 else if ((cmd & 0xFFFF) == 0xFFFD)
200 {
201 CString tempfile = GetTempFile();
202 CString cmd = _T("git.exe diff-tree --cc ") + r1->m_CommitHash.ToString();
203 CString lastErr;
204 if (g_Git.RunLogFile(cmd, tempfile, &lastErr))
205 {
206 MessageBox(lastErr, _T("TortoiseGit"), MB_ICONERROR);
207 break;
208 }
209
210 CAppUtils::StartUnifiedDiffViewer(tempfile, _T("dd"));
211 break;
212 }
213 else
214 {
215 if(cmd > r1->m_ParentHash.size())
216 {
217 CString str;
218 str.Format(IDS_PROC_NOPARENT, cmd);
219 MessageBox(str, _T("TortoiseGit"), MB_OK | MB_ICONERROR);
220 return;
221 }
222 else
223 {
224 if(cmd>0)
225 hash2 = r1->m_ParentHash[cmd-1].ToString();
226 }
227 }
228 CAppUtils::StartShowUnifiedDiff(nullptr, CTGitPath(), hash2, CTGitPath(), r1->m_CommitHash.ToString(), false, false, false, bMerge, bCombine);
229 }
230 else
231 CAppUtils::StartShowUnifiedDiff(nullptr, CTGitPath(), _T("HEAD"), CTGitPath(), GitRev::GetWorkingCopy(), false, false, false, bMerge, bCombine);
232 }
233 break;
234
235 case ID_GNUDIFF2: // compare two revisions, unified
236 {
237 GitRev * r1 = reinterpret_cast<GitRev*>(m_arShownList.GetAt(FirstSelect));
238 GitRev * r2 = reinterpret_cast<GitRev*>(m_arShownList.GetAt(LastSelect));
239 CAppUtils::StartShowUnifiedDiff(nullptr, CTGitPath(), r2->m_CommitHash.ToString(), CTGitPath(), r1->m_CommitHash.ToString());
240 }
241 break;
242
243 case ID_COMPARETWO: // compare two revisions
244 {
245 GitRev * r1 = reinterpret_cast<GitRev*>(m_arShownList.GetAt(FirstSelect));
246 GitRev * r2 = reinterpret_cast<GitRev*>(m_arShownList.GetAt(LastSelect));
247 if (m_Path.IsDirectory() || !(m_ShowMask & CGit::LOG_INFO_FOLLOW))
248 CGitDiff::DiffCommit(this->m_Path, r1,r2);
249 else
250 {
251 CString path1 = m_Path.GetGitPathString();
252 // start with 1 (0 = working copy changes)
253 for (int i = 1; i < FirstSelect; ++i)
254 {
255 GitRevLoglist* first = reinterpret_cast<GitRevLoglist*>(m_arShownList.GetAt(i));
256 CTGitPathList list = first->GetFiles(NULL);
257 CTGitPath * file = list.LookForGitPath(path1);
258 if (file && !file->GetGitOldPathString().IsEmpty())
259 path1 = file->GetGitOldPathString();
260 }
261 CString path2 = path1;
262 for (int i = FirstSelect; i < LastSelect; ++i)
263 {
264 GitRevLoglist* first = reinterpret_cast<GitRevLoglist*>(m_arShownList.GetAt(i));
265 CTGitPathList list = first->GetFiles(NULL);
266 CTGitPath * file = list.LookForGitPath(path2);
267 if (file && !file->GetGitOldPathString().IsEmpty())
268 path2 = file->GetGitOldPathString();
269 }
270 CGitDiff::DiffCommit(CTGitPath(path1), CTGitPath(path2), r1, r2);
271 }
272
273 }
274 break;
275
276 case ID_COMPARE: // compare revision with WC
277 {
278 GitRevLoglist* r1 = &m_wcRev;
279 GitRevLoglist* r2 = pSelLogEntry;
280
281 if (m_Path.IsDirectory() || !(m_ShowMask & CGit::LOG_INFO_FOLLOW))
282 CGitDiff::DiffCommit(this->m_Path, r1,r2);
283 else
284 {
285 CString path1 = m_Path.GetGitPathString();
286 // start with 1 (0 = working copy changes)
287 for (int i = 1; i < FirstSelect; ++i)
288 {
289 GitRevLoglist* first = reinterpret_cast<GitRevLoglist*>(m_arShownList.GetAt(i));
290 CTGitPathList list = first->GetFiles(NULL);
291 CTGitPath * file = list.LookForGitPath(path1);
292 if (file && !file->GetGitOldPathString().IsEmpty())
293 path1 = file->GetGitOldPathString();
294 }
295 CGitDiff::DiffCommit(m_Path, CTGitPath(path1), r1, r2);
296 }
297
298 //user clicked on the menu item "compare with working copy"
299 //if (PromptShown())
300 //{
301 // GitDiff diff(this, m_hWnd, true);
302 // diff.SetAlternativeTool(!!(GetAsyncKeyState(VK_SHIFT) & 0x8000));
303 // diff.SetHEADPeg(m_LogRevision);
304 // diff.ShowCompare(m_path, GitRev::REV_WC, m_path, revSelected);
305 //}
306 //else
307 // CAppUtils::StartShowCompare(m_hWnd, m_path, GitRev::REV_WC, m_path, revSelected, GitRev(), m_LogRevision, !!(GetAsyncKeyState(VK_SHIFT) & 0x8000));
308 }
309 break;
310
311 case ID_COMPAREWITHPREVIOUS:
312 {
313 CFileDiffDlg dlg;
314
315 if (pSelLogEntry->m_ParentHash.empty())
316 {
317 if (pSelLogEntry->GetParentFromHash(pSelLogEntry->m_CommitHash))
318 MessageBox(pSelLogEntry->GetLastErr(), _T("TortoiseGit"), MB_ICONERROR);
319 }
320
321 if (!pSelLogEntry->m_ParentHash.empty())
322 //if(m_logEntries.m_HashMap[pSelLogEntry->m_ParentHash[0]]>=0)
323 {
324 cmd>>=16;
325 cmd&=0xFFFF;
326
327 if(cmd == 0)
328 cmd=1;
329
330 if (m_Path.IsDirectory() || !(m_ShowMask & CGit::LOG_INFO_FOLLOW))
331 CGitDiff::DiffCommit(m_Path, pSelLogEntry->m_CommitHash.ToString(), pSelLogEntry->m_ParentHash[cmd - 1].ToString());
332 else
333 {
334 CString path1 = m_Path.GetGitPathString();
335 // start with 1 (0 = working copy changes)
336 for (int i = 1; i < indexNext; ++i)
337 {
338 GitRevLoglist* first = reinterpret_cast<GitRevLoglist*>(m_arShownList.GetAt(i));
339 CTGitPathList list = first->GetFiles(NULL);
340 CTGitPath * file = list.LookForGitPath(path1);
341 if (file && !file->GetGitOldPathString().IsEmpty())
342 path1 = file->GetGitOldPathString();
343 }
344 CString path2 = path1;
345 GitRevLoglist* first = reinterpret_cast<GitRevLoglist*>(m_arShownList.GetAt(indexNext));
346 CTGitPathList list = first->GetFiles(NULL);
347 CTGitPath * file = list.LookForGitPath(path2);
348 if (file && !file->GetGitOldPathString().IsEmpty())
349 path2 = file->GetGitOldPathString();
350
351 CGitDiff::DiffCommit(CTGitPath(path1), CTGitPath(path2), pSelLogEntry->m_CommitHash.ToString(), pSelLogEntry->m_ParentHash[cmd - 1].ToString());
352 }
353 }
354 else
355 {
356 CMessageBox::Show(NULL, IDS_PROC_NOPREVIOUSVERSION, IDS_APPNAME, MB_OK);
357 }
358 //if (PromptShown())
359 //{
360 // GitDiff diff(this, m_hWnd, true);
361 // diff.SetAlternativeTool(!!(GetAsyncKeyState(VK_SHIFT) & 0x8000));
362 // diff.SetHEADPeg(m_LogRevision);
363 // diff.ShowCompare(CTGitPath(pathURL), revPrevious, CTGitPath(pathURL), revSelected);
364 //}
365 //else
366 // CAppUtils::StartShowCompare(m_hWnd, CTGitPath(pathURL), revPrevious, CTGitPath(pathURL), revSelected, GitRev(), m_LogRevision, !!(GetAsyncKeyState(VK_SHIFT) & 0x8000));
367 }
368 break;
369 case ID_LOG_VIEWRANGE:
370 case ID_LOG_VIEWRANGE_REACHABLEFROMONLYONE:
371 {
372 GitRev* pLastEntry = reinterpret_cast<GitRev*>(m_arShownList.SafeGetAt(LastSelect));
373
374 CString sep = _T("..");
375 if ((cmd & 0xFFFF) == ID_LOG_VIEWRANGE_REACHABLEFROMONLYONE)
376 sep = _T("...");
377
378 CString cmdline;
379 cmdline.Format(_T("/command:log /path:\"%s\" /range:\"%s%s%s\""),
380 g_Git.CombinePath(m_Path), pLastEntry->m_CommitHash.ToString(), sep, pSelLogEntry->m_CommitHash.ToString());
381 CAppUtils::RunTortoiseGitProc(cmdline);
382 }
383 break;
384 case ID_COPYCLIPBOARD:
385 {
386 CopySelectionToClipBoard();
387 }
388 break;
389 case ID_COPYCLIPBOARDMESSAGES:
390 {
391 if ((GetAsyncKeyState(VK_SHIFT) & 0x8000) != 0)
392 CopySelectionToClipBoard(ID_COPY_SUBJECT);
393 else
394 CopySelectionToClipBoard(ID_COPY_MESSAGE);
395 }
396 break;
397 case ID_COPYHASH:
398 {
399 CopySelectionToClipBoard(ID_COPY_HASH);
400 }
401 break;
402 case ID_EXPORT:
403 {
404 CString str=pSelLogEntry->m_CommitHash.ToString();
405 // try to get the tag
406 for (size_t i = 0; i < m_HashMap[pSelLogEntry->m_CommitHash].size(); ++i)
407 {
408 if (m_HashMap[pSelLogEntry->m_CommitHash][i].Find(_T("refs/tags/")) == 0)
409 {
410 str = m_HashMap[pSelLogEntry->m_CommitHash][i];
411 break;
412 }
413 }
414 CAppUtils::Export(&str, &m_Path);
415 }
416 break;
417 case ID_CREATE_BRANCH:
418 case ID_CREATE_TAG:
419 {
420 CString str = pSelLogEntry->m_CommitHash.ToString();
421 // try to guess remote branch in order to enable tracking
422 for (size_t i = 0; i < m_HashMap[pSelLogEntry->m_CommitHash].size(); ++i)
423 {
424 if (m_HashMap[pSelLogEntry->m_CommitHash][i].Find(_T("refs/remotes/")) == 0)
425 {
426 str = m_HashMap[pSelLogEntry->m_CommitHash][i];
427 break;
428 }
429 }
430 CAppUtils::CreateBranchTag((cmd&0xFFFF) == ID_CREATE_TAG, &str);
431 ReloadHashMap();
432 if (m_pFindDialog)
433 m_pFindDialog->RefreshList();
434 Invalidate();
435 ::PostMessage(this->GetParent()->m_hWnd,MSG_REFLOG_CHANGED,0,0);
436 }
437 break;
438 case ID_SWITCHTOREV:
439 {
440 CString str = pSelLogEntry->m_CommitHash.ToString();
441 // try to guess remote branch in order to recommend good branch name and tracking
442 for (size_t i = 0; i < m_HashMap[pSelLogEntry->m_CommitHash].size(); ++i)
443 {
444 if (m_HashMap[pSelLogEntry->m_CommitHash][i].Find(_T("refs/remotes/")) == 0)
445 {
446 str = m_HashMap[pSelLogEntry->m_CommitHash][i];
447 break;
448 }
449 }
450 CAppUtils::Switch(str);
451 }
452 ReloadHashMap();
453 Invalidate();
454 ::PostMessage(this->GetParent()->m_hWnd,MSG_REFLOG_CHANGED,0,0);
455 break;
456 case ID_SWITCHBRANCH:
457 if(popmenu)
458 {
459 CString *branch = (CString*)((CIconMenu*)popmenu)->GetMenuItemData(cmd);
460 if(branch)
461 {
462 CString name;
463 if(branch->Find(_T("refs/heads/")) ==0 )
464 name = branch->Mid(11);
465 else
466 name = *branch;
467
468 CAppUtils::PerformSwitch(name);
469 }
470 ReloadHashMap();
471 Invalidate();
472 ::PostMessage(this->GetParent()->m_hWnd,MSG_REFLOG_CHANGED,0,0);
473 }
474 break;
475 case ID_RESET:
476 {
477 CString str = pSelLogEntry->m_CommitHash.ToString();
478 if (CAppUtils::GitReset(&str))
479 {
480 ResetWcRev(true);
481 ReloadHashMap();
482 Invalidate();
483 }
484 }
485 break;
486 case ID_REBASE_PICK:
487 SetSelectedRebaseAction(LOGACTIONS_REBASE_PICK);
488 break;
489 case ID_REBASE_EDIT:
490 SetSelectedRebaseAction(LOGACTIONS_REBASE_EDIT);
491 break;
492 case ID_REBASE_SQUASH:
493 SetSelectedRebaseAction(LOGACTIONS_REBASE_SQUASH);
494 break;
495 case ID_REBASE_SKIP:
496 SetSelectedRebaseAction(LOGACTIONS_REBASE_SKIP);
497 break;
498 case ID_COMBINE_COMMIT:
499 {
500 CString head;
501 CGitHash headhash;
502 CGitHash hashFirst,hashLast;
503
504 int headindex=GetHeadIndex();
505 if(headindex>=0) //incase show all branch, head is not the first commits.
506 {
507 head.Format(_T("HEAD~%d"),FirstSelect-headindex);
508 if (g_Git.GetHash(hashFirst, head))
509 {
510 MessageBox(g_Git.GetGitLastErr(_T("Could not get hash of first selected revision.")), _T("TortoiseGit"), MB_ICONERROR);
511 break;
512 }
513
514 head.Format(_T("HEAD~%d"),LastSelect-headindex);
515 if (g_Git.GetHash(hashLast, head))
516 {
517 MessageBox(g_Git.GetGitLastErr(_T("Could not get hash of last selected revision.")), _T("TortoiseGit"), MB_ICONERROR);
518 break;
519 }
520 }
521
522 GitRev* pFirstEntry = reinterpret_cast<GitRev*>(m_arShownList.GetAt(FirstSelect));
523 GitRev* pLastEntry = reinterpret_cast<GitRev*>(m_arShownList.GetAt(LastSelect));
524 if(pFirstEntry->m_CommitHash != hashFirst || pLastEntry->m_CommitHash != hashLast)
525 {
526 CMessageBox::Show(NULL, IDS_PROC_CANNOTCOMBINE, IDS_APPNAME, MB_OK);
527 break;
528 }
529
530 GitRev lastRevision;
531 if (lastRevision.GetParentFromHash(hashLast))
532 {
533 MessageBox(lastRevision.GetLastErr(), _T("TortoiseGit"), MB_ICONERROR);
534 break;
535 }
536
537 if (g_Git.GetHash(headhash, _T("HEAD")))
538 {
539 MessageBox(g_Git.GetGitLastErr(_T("Could not get HEAD hash.")), _T("TortoiseGit"), MB_ICONERROR);
540 break;
541 }
542
543 if(!g_Git.CheckCleanWorkTree())
544 {
545 CMessageBox::Show(NULL, IDS_PROC_NOCLEAN, IDS_APPNAME, MB_OK);
546 break;
547 }
548 CString sCmd, out;
549
550 //Use throw to abort this process (reset back to original HEAD)
551 try
552 {
553 sCmd.Format(_T("git.exe reset --hard %s --"), pFirstEntry->m_CommitHash.ToString());
554 if(g_Git.Run(sCmd, &out, CP_UTF8))
555 {
556 CMessageBox::Show(NULL,out,_T("TortoiseGit"),MB_OK);
557 throw std::exception(CUnicodeUtils::GetUTF8(CString(MAKEINTRESOURCE(IDS_PROC_COMBINE_ERRORSTEP1)) + _T("\r\n\r\n") + out));
558 }
559 sCmd.Format(_T("git.exe reset --mixed %s --"), hashLast.ToString());
560 if(g_Git.Run(sCmd, &out, CP_UTF8))
561 {
562 CMessageBox::Show(NULL,out,_T("TortoiseGit"),MB_OK);
563 throw std::exception(CUnicodeUtils::GetUTF8(CString(MAKEINTRESOURCE(IDS_PROC_COMBINE_ERRORSTEP2)) + _T("\r\n\r\n")+out));
564 }
565
566 CTGitPathList PathList;
567 /* don't why must add --stat to get action status*/
568 /* first -z will be omitted by gitdll*/
569 if(g_Git.GetDiffPath(&PathList,&pFirstEntry->m_CommitHash,&hashLast,"-z --stat -r"))
570 {
571 CMessageBox::Show(NULL,_T("Get Diff file list error"),_T("TortoiseGit"),MB_OK);
572 throw std::exception(CUnicodeUtils::GetUTF8(_T("Could not get changed file list aborting...\r\n\r\n")+out));
573 }
574
575 for (int i = 0; i < PathList.GetCount(); ++i)
576 {
577 if(PathList[i].m_Action & CTGitPath::LOGACTIONS_ADDED)
578 {
579 sCmd.Format(_T("git.exe add -- \"%s\""), PathList[i].GetGitPathString());
580 if (g_Git.Run(sCmd, &out, CP_UTF8))
581 {
582 CMessageBox::Show(NULL,out,_T("TortoiseGit"),MB_OK);
583 throw std::exception(CUnicodeUtils::GetUTF8(_T("Could not add new file aborting...\r\n\r\n")+out));
584
585 }
586 }
587 if(PathList[i].m_Action & CTGitPath::LOGACTIONS_DELETED)
588 {
589 sCmd.Format(_T("git.exe rm -- \"%s\""), PathList[i].GetGitPathString());
590 if (g_Git.Run(sCmd, &out, CP_UTF8))
591 {
592 CMessageBox::Show(NULL,out,_T("TortoiseGit"),MB_OK);
593 throw std::exception(CUnicodeUtils::GetUTF8(_T("Could not rm file aborting...\r\n\r\n")+out));
594 }
595 }
596 }
597
598 CCommitDlg dlg;
599 for (int i = FirstSelect; i <= LastSelect; ++i)
600 {
601 GitRev* pRev = reinterpret_cast<GitRev*>(m_arShownList.GetAt(i));
602 dlg.m_sLogMessage+=pRev->GetSubject()+_T("\n")+pRev->GetBody();
603 dlg.m_sLogMessage+=_T("\n");
604 }
605 dlg.m_bWholeProject=true;
606 dlg.m_bSelectFilesForCommit = true;
607 dlg.m_bForceCommitAmend=true;
608 CTGitPathList gpl;
609 gpl.AddPath(CTGitPath(g_Git.m_CurrentDir));
610 dlg.m_pathList = gpl;
611 if (lastRevision.ParentsCount() != 1)
612 {
613 CMessageBox::Show(NULL, _T("The following commit dialog can only show changes of oldest commit if it has exactly one parent. This is not the case right now."), _T("TortoiseGit"),MB_OK);
614 dlg.m_bAmendDiffToLastCommit = TRUE;
615 }
616 else
617 dlg.m_bAmendDiffToLastCommit = FALSE;
618 dlg.m_bNoPostActions=true;
619 dlg.m_AmendStr=dlg.m_sLogMessage;
620
621 if (dlg.DoModal() == IDOK)
622 {
623 if(pFirstEntry->m_CommitHash!=headhash)
624 {
625 if(CherryPickFrom(pFirstEntry->m_CommitHash.ToString(),headhash))
626 {
627 CString msg;
628 msg.Format(_T("Error while cherry pick commits on top of combined commits. Aborting.\r\n\r\n"));
629 throw std::exception(CUnicodeUtils::GetUTF8(msg));
630 }
631 }
632 }
633 else
634 throw std::exception(CUnicodeUtils::GetUTF8(CString(MAKEINTRESOURCE(IDS_SVN_USERCANCELLED))));
635 }
636 catch(std::exception& e)
637 {
638 CMessageBox::Show(NULL, CUnicodeUtils::GetUnicode(CStringA(e.what())), _T("TortoiseGit"), MB_OK | MB_ICONERROR);
639 sCmd.Format(_T("git.exe reset --hard %s --"), headhash.ToString());
640 out.Empty();
641 if(g_Git.Run(sCmd, &out, CP_UTF8))
642 {
643 CMessageBox::Show(NULL, CString(MAKEINTRESOURCE(IDS_PROC_COMBINE_ERRORRESETHEAD)) + _T("\r\n\r\n") + out, _T("TortoiseGit"), MB_OK);
644 }
645 }
646 Refresh();
647 }
648 break;
649
650 case ID_CHERRY_PICK:
651 {
652 if (m_bThreadRunning)
653 {
654 CMessageBox::Show(GetSafeHwnd(), IDS_PROC_LOG_ONLYONCE, IDS_APPNAME, MB_ICONEXCLAMATION);
655 break;
656 }
657 CRebaseDlg dlg;
658 dlg.m_IsCherryPick = TRUE;
659 dlg.m_Upstream = this->m_CurrentBranch;
660 POSITION pos2 = GetFirstSelectedItemPosition();
661 while(pos2)
662 {
663 int indexNext2 = GetNextSelectedItem(pos2);
664 dlg.m_CommitList.m_logEntries.push_back(((GitRevLoglist*)m_arShownList[indexNext2])->m_CommitHash);
665 dlg.m_CommitList.m_LogCache.m_HashMap[((GitRevLoglist*)m_arShownList[indexNext2])->m_CommitHash] = *(GitRevLoglist*)m_arShownList[indexNext2];
666 dlg.m_CommitList.m_logEntries.GetGitRevAt(dlg.m_CommitList.m_logEntries.size() - 1).GetRebaseAction() |= LOGACTIONS_REBASE_PICK;
667 }
668
669 if(dlg.DoModal() == IDOK)
670 {
671 Refresh();
672 }
673 }
674 break;
675 case ID_REBASE_TO_VERSION:
676 {
677 if (m_bThreadRunning)
678 {
679 CMessageBox::Show(GetSafeHwnd(), IDS_PROC_LOG_ONLYONCE, IDS_APPNAME, MB_ICONEXCLAMATION);
680 break;
681 }
682 CRebaseDlg dlg;
683 auto refList = m_HashMap[pSelLogEntry->m_CommitHash];
684 dlg.m_Upstream = refList.empty() ? pSelLogEntry->m_CommitHash.ToString() : refList.front();
685 for (auto ref : refList)
686 {
687 if (ref.Left(11) == _T("refs/heads/"))
688 {
689 // 11=len("refs/heads/")
690 dlg.m_Upstream = ref.Mid(11);
691 break;
692 }
693 }
694
695 if(dlg.DoModal() == IDOK)
696 {
697 Refresh();
698 }
699 }
700
701 break;
702
703 case ID_STASH_SAVE:
704 if (CAppUtils::StashSave())
705 Refresh();
706 break;
707
708 case ID_STASH_POP:
709 if (CAppUtils::StashPop())
710 Refresh();
711 break;
712
713 case ID_STASH_LIST:
714 CAppUtils::RunTortoiseGitProc(_T("/command:reflog /ref:refs/stash"));
715 break;
716
717 case ID_REFLOG_STASH_APPLY:
718 CAppUtils::StashApply(pSelLogEntry->m_Ref);
719 break;
720
721 case ID_REFLOG_DEL:
722 {
723 CString str;
724 if (GetSelectedCount() > 1)
725 str.Format(IDS_PROC_DELETENREFS, GetSelectedCount());
726 else
727 str.Format(IDS_PROC_DELETEREF, pSelLogEntry->m_Ref);
728
729 if (CMessageBox::Show(NULL, str, _T("TortoiseGit"), 1, IDI_QUESTION, CString(MAKEINTRESOURCE(IDS_DELETEBUTTON)), CString(MAKEINTRESOURCE(IDS_ABORTBUTTON))) == 2)
730 return;
731
732 std::vector<CString> refsToDelete;
733 POSITION pos2 = GetFirstSelectedItemPosition();
734 while (pos2)
735 {
736 CString ref = ((GitRevLoglist*)m_arShownList[GetNextSelectedItem(pos2)])->m_Ref;
737 if (ref.Find(_T("refs/")) == 0)
738 ref = ref.Mid(5);
739 int refpos = ref.ReverseFind('{');
740 if (refpos > 0 && ref.Mid(refpos - 1, 2) != _T("@{"))
741 ref = ref.Left(refpos) + _T("@")+ ref.Mid(refpos);
742 refsToDelete.push_back(ref);
743 }
744
745 for (auto revIt = refsToDelete.rbegin(); revIt != refsToDelete.rend(); ++revIt)
746 {
747 CString ref = *revIt;
748 CString sCmd, out;
749 if (ref.Find(_T("stash")) == 0)
750 sCmd.Format(_T("git.exe stash drop %s"), ref);
751 else
752 sCmd.Format(_T("git.exe reflog delete %s"), ref);
753
754 if (g_Git.Run(sCmd, &out, CP_UTF8))
755 CMessageBox::Show(NULL,out,_T("TortoiseGit"),MB_OK);
756
757 ::PostMessage(this->GetParent()->m_hWnd,MSG_REFLOG_CHANGED,0,0);
758 }
759 }
760 break;
761 case ID_LOG:
762 {
763 CString sCmd = _T("/command:log");
764 sCmd += _T(" /path:\"") + g_Git.m_CurrentDir + _T("\" ");
765 GitRev * r1 = reinterpret_cast<GitRev*>(m_arShownList.GetAt(FirstSelect));
766 sCmd += _T(" /endrev:") + r1->m_CommitHash.ToString();
767 CAppUtils::RunTortoiseGitProc(sCmd);
768 }
769 break;
770 case ID_CREATE_PATCH:
771 {
772 int select=this->GetSelectedCount();
773 CString sCmd = _T("/command:formatpatch");
774 sCmd += _T(" /path:\"") + g_Git.m_CurrentDir + _T("\" ");
775
776 GitRev * r1 = reinterpret_cast<GitRev*>(m_arShownList.GetAt(FirstSelect));
777 GitRev * r2 = NULL;
778 if(select == 1)
779 {
780 sCmd += _T(" /startrev:") + r1->m_CommitHash.ToString();
781 }
782 else
783 {
784 r2 = reinterpret_cast<GitRev*>(m_arShownList.GetAt(LastSelect));
785 if( this->m_IsOldFirst )
786 {
787 sCmd += _T(" /startrev:") + r1->m_CommitHash.ToString() + _T("~1");
788 sCmd += _T(" /endrev:") + r2->m_CommitHash.ToString();
789
790 }
791 else
792 {
793 sCmd += _T(" /startrev:") + r2->m_CommitHash.ToString() + _T("~1");
794 sCmd += _T(" /endrev:") + r1->m_CommitHash.ToString();
795 }
796
797 }
798
799 CAppUtils::RunTortoiseGitProc(sCmd);
800 }
801 break;
802 case ID_BISECTSTART:
803 {
804 GitRev * first = reinterpret_cast<GitRev*>(m_arShownList.GetAt(FirstSelect));
805 GitRev * last = reinterpret_cast<GitRev*>(m_arShownList.GetAt(LastSelect));
806 ASSERT(first != NULL && last != NULL);
807
808 CString firstBad = first->m_CommitHash.ToString();
809 if (!m_HashMap[first->m_CommitHash].empty())
810 firstBad = m_HashMap[first->m_CommitHash].at(0);
811 CString lastGood = last->m_CommitHash.ToString();
812 if (!m_HashMap[last->m_CommitHash].empty())
813 lastGood = m_HashMap[last->m_CommitHash].at(0);
814
815 if (CAppUtils::BisectStart(lastGood, firstBad))
816 Refresh();
817 }
818 break;
819 case ID_REPOBROWSE:
820 {
821 CString sCmd;
822 sCmd.Format(_T("/command:repobrowser /path:\"%s\" /rev:%s"), g_Git.m_CurrentDir, pSelLogEntry->m_CommitHash.ToString());
823 CAppUtils::RunTortoiseGitProc(sCmd);
824 }
825 break;
826 case ID_PUSH:
827 {
828 CString guessAssociatedBranch = pSelLogEntry->m_CommitHash;
829 if (!m_HashMap[pSelLogEntry->m_CommitHash].empty() && m_HashMap[pSelLogEntry->m_CommitHash].at(0).Find(_T("refs/heads/")) == 0)
830 guessAssociatedBranch = m_HashMap[pSelLogEntry->m_CommitHash].at(0);
831 if (CAppUtils::Push(guessAssociatedBranch))
832 Refresh();
833 }
834 break;
835 case ID_PULL:
836 {
837 if (CAppUtils::Pull())
838 Refresh();
839 }
840 break;
841 case ID_FETCH:
842 {
843 if (CAppUtils::Fetch())
844 Refresh();
845 }
846 break;
847 case ID_CLEANUP:
848 {
849 CString sCmd;
850 sCmd.Format(_T("/command:cleanup /path:\"%s\""), g_Git.m_CurrentDir);
851 CAppUtils::RunTortoiseGitProc(sCmd);
852 }
853 break;
854 case ID_SUBMODULE_UPDATE:
855 {
856 CString sCmd;
857 sCmd.Format(_T("/command:subupdate /bkpath:\"%s\""), g_Git.m_CurrentDir);
858 CAppUtils::RunTortoiseGitProc(sCmd);
859 }
860 break;
861 case ID_SHOWBRANCHES:
862 {
863 CString sCmd;
864 sCmd.Format(_T("git.exe branch -a --contains %s"), pSelLogEntry->m_CommitHash.ToString());
865 CProgressDlg progress;
866 progress.m_AutoClose = AUTOCLOSE_NO;
867 progress.m_GitCmd = sCmd;
868 progress.DoModal();
869 }
870 break;
871 case ID_DELETE:
872 {
873 CString *branch = (CString*)((CIconMenu*)popmenu)->GetMenuItemData(cmd);
874 if (!branch)
875 {
876 CMessageBox::Show(NULL,IDS_ERROR_NOREF,IDS_APPNAME,MB_OK|MB_ICONERROR);
877 return;
878 }
879 CString shortname;
880 if (CGit::GetShortName(*branch, shortname, _T("refs/remotes/")))
881 {
882 CString msg;
883 msg.Format(IDS_PROC_DELETEREMOTEBRANCH, *branch);
884 int result = CMessageBox::Show(NULL, msg, _T("TortoiseGit"), 3, IDI_QUESTION, CString(MAKEINTRESOURCE(IDS_PROC_DELETEREMOTEBRANCH_LOCALREMOTE)), CString(MAKEINTRESOURCE(IDS_PROC_DELETEREMOTEBRANCH_LOCAL)), CString(MAKEINTRESOURCE(IDS_ABORTBUTTON)));
885 if (result == 1)
886 {
887 CString remoteName = shortname.Left(shortname.Find('/'));
888 shortname = shortname.Mid(shortname.Find('/') + 1);
889 if(CAppUtils::IsSSHPutty())
890 CAppUtils::LaunchPAgent(NULL, &remoteName);
891
892 CSysProgressDlg sysProgressDlg;
893 sysProgressDlg.SetTitle(CString(MAKEINTRESOURCE(IDS_APPNAME)));
894 sysProgressDlg.SetLine(1, CString(MAKEINTRESOURCE(IDS_DELETING_REMOTE_REFS)));
895 sysProgressDlg.SetLine(2, CString(MAKEINTRESOURCE(IDS_PROGRESSWAIT)));
896 sysProgressDlg.SetShowProgressBar(false);
897 sysProgressDlg.ShowModal(this, true);
898 STRING_VECTOR list;
899 list.push_back(_T("refs/heads/") + shortname);
900 if (g_Git.DeleteRemoteRefs(remoteName, list))
901 CMessageBox::Show(NULL, g_Git.GetGitLastErr(_T("Could not delete remote ref."), CGit::GIT_CMD_PUSH), _T("TortoiseGit"), MB_OK | MB_ICONERROR);
902 sysProgressDlg.Stop();
903 }
904 else if (result == 2)
905 {
906 if (g_Git.DeleteRef(*branch))
907 {
908 CMessageBox::Show(nullptr, g_Git.GetGitLastErr(L"Could not delete reference.", CGit::GIT_CMD_DELETETAGBRANCH), _T("TortoiseGit"), MB_OK | MB_ICONERROR);
909 return;
910 }
911 }
912 else
913 return;
914 }
915 else if (CGit::GetShortName(*branch, shortname, _T("refs/stash")))
916 {
917 if (CMessageBox::Show(NULL, IDS_PROC_DELETEALLSTASH, IDS_APPNAME, 2, IDI_QUESTION, IDS_DELETEBUTTON, IDS_ABORTBUTTON) == 1)
918 {
919 CString sCmd;
920 sCmd.Format(_T("git.exe stash clear"));
921 CString out;
922 if (g_Git.Run(sCmd, &out, CP_UTF8))
923 CMessageBox::Show(NULL, out, _T("TortoiseGit"), MB_OK | MB_ICONERROR);
924 }
925 else
926 return;
927 }
928 else
929 {
930 CString msg;
931 msg.Format(IDS_PROC_DELETEBRANCHTAG, *branch);
932 if (CMessageBox::Show(NULL, msg, _T("TortoiseGit"), 2, IDI_QUESTION, CString(MAKEINTRESOURCE(IDS_DELETEBUTTON)), CString(MAKEINTRESOURCE(IDS_ABORTBUTTON))) == 1)
933 {
934 if (g_Git.DeleteRef(*branch))
935 {
936 CMessageBox::Show(nullptr, g_Git.GetGitLastErr(L"Could not delete reference.", CGit::GIT_CMD_DELETETAGBRANCH), _T("TortoiseGit"), MB_OK | MB_ICONERROR);
937 return;
938 }
939 }
940 }
941 this->ReloadHashMap();
942 if (m_pFindDialog)
943 m_pFindDialog->RefreshList();
944 CRect rect;
945 this->GetItemRect(FirstSelect,&rect,LVIR_BOUNDS);
946 this->InvalidateRect(rect);
947 }
948 break;
949
950 case ID_FINDENTRY:
951 {
952 m_nSearchIndex = GetSelectionMark();
953 if (m_nSearchIndex < 0)
954 m_nSearchIndex = 0;
955 if (m_pFindDialog)
956 {
957 break;
958 }
959 else
960 {
961 m_pFindDialog = new CFindDlg();
962 m_pFindDialog->Create(this);
963 }
964 }
965 break;
966 case ID_MERGEREV:
967 {
968 CString str = pSelLogEntry->m_CommitHash.ToString();
969 if (!m_HashMap[pSelLogEntry->m_CommitHash].empty())
970 str = m_HashMap[pSelLogEntry->m_CommitHash].at(0);
971 // we need an URL to complete this command, so error out if we can't get an URL
972 if(CAppUtils::Merge(&str))
973 {
974 this->Refresh();
975 }
976 }
977 break;
978 case ID_REVERTREV:
979 {
980 int parent = 0;
981 if (GetSelectedCount() == 1)
982 {
983 parent = cmd >> 16;
984 if (parent > pSelLogEntry->m_ParentHash.size())
985 {
986 CString str;
987 str.Format(IDS_PROC_NOPARENT, parent);
988 MessageBox(str, _T("TortoiseGit"), MB_OK | MB_ICONERROR);
989 return;
990 }
991 }
992
993 if (!this->RevertSelectedCommits(parent))
994 {
995 if (CMessageBox::Show(m_hWnd, IDS_REVREVERTED, IDS_APPNAME, 1, IDI_QUESTION, IDS_OKBUTTON, IDS_COMMITBUTTON) == 2)
996 {
997 CTGitPathList pathlist;
998 CTGitPathList selectedlist;
999 pathlist.AddPath(this->m_Path);
1000 bool bSelectFilesForCommit = !!DWORD(CRegStdDWORD(_T("Software\\TortoiseGit\\SelectFilesForCommit"), TRUE));
1001 CString str;
1002 CAppUtils::Commit(CString(), false, str, pathlist, selectedlist, bSelectFilesForCommit);
1003 }
1004 this->Refresh();
1005 }
1006 }
1007 break;
1008 case ID_EDITNOTE:
1009 {
1010 CAppUtils::EditNote(pSelLogEntry);
1011 this->SetItemState(FirstSelect, 0, LVIS_SELECTED);
1012 this->SetItemState(FirstSelect, LVIS_SELECTED, LVIS_SELECTED);
1013 }
1014 break;
1015 default:
1016 //CMessageBox::Show(NULL,_T("Have not implemented"),_T("TortoiseGit"),MB_OK);
1017 break;
1018 #if 0
1019
1020 case ID_BLAMECOMPARE:
1021 {
1022 //user clicked on the menu item "compare with working copy"
1023 //now first get the revision which is selected
1024 if (PromptShown())
1025 {
1026 GitDiff diff(this, this->m_hWnd, true);
1027 diff.SetHEADPeg(m_LogRevision);
1028 diff.ShowCompare(m_path, GitRev::REV_BASE, m_path, revSelected, GitRev(), false, true);
1029 }
1030 else
1031 CAppUtils::StartShowCompare(m_hWnd, m_path, GitRev::REV_BASE, m_path, revSelected, GitRev(), m_LogRevision, false, false, true);
1032 }
1033 break;
1034 case ID_BLAMEWITHPREVIOUS:
1035 {
1036 //user clicked on the menu item "Compare and Blame with previous revision"
1037 if (PromptShown())
1038 {
1039 GitDiff diff(this, this->m_hWnd, true);
1040 diff.SetHEADPeg(m_LogRevision);
1041 diff.ShowCompare(CTGitPath(pathURL), revPrevious, CTGitPath(pathURL), revSelected, GitRev(), false, true);
1042 }
1043 else
1044 CAppUtils::StartShowCompare(m_hWnd, CTGitPath(pathURL), revPrevious, CTGitPath(pathURL), revSelected, GitRev(), m_LogRevision, false, false, true);
1045 }
1046 break;
1047
1048 case ID_OPENWITH:
1049 bOpenWith = true;
1050 case ID_OPEN:
1051 {
1052 CProgressDlg progDlg;
1053 progDlg.SetTitle(IDS_APPNAME);
1054 progDlg.SetAnimation(IDR_DOWNLOAD);
1055 CString sInfoLine;
1056 sInfoLine.Format(IDS_PROGRESSGETFILEREVISION, m_path.GetWinPath(), (LPCTSTR)revSelected.ToString());
1057 progDlg.SetLine(1, sInfoLine, true);
1058 SetAndClearProgressInfo(&progDlg);
1059 progDlg.ShowModeless(m_hWnd);
1060 CTGitPath tempfile = CTempFiles::Instance().GetTempFilePath(false, m_path, revSelected);
1061 bool bSuccess = true;
1062 if (!Cat(m_path, GitRev(GitRev::REV_HEAD), revSelected, tempfile))
1063 {
1064 bSuccess = false;
1065 // try again, but with the selected revision as the peg revision
1066 if (!Cat(m_path, revSelected, revSelected, tempfile))
1067 {
1068 progDlg.Stop();
1069 SetAndClearProgressInfo((HWND)NULL);
1070 CMessageBox::Show(this->m_hWnd, GetLastErrorMessage(), _T("TortoiseGit"), MB_ICONERROR);
1071 EnableOKButton();
1072 break;
1073 }
1074 bSuccess = true;
1075 }
1076 if (bSuccess)
1077 {
1078 progDlg.Stop();
1079 SetAndClearProgressInfo((HWND)NULL);
1080 SetFileAttributes(tempfile.GetWinPath(), FILE_ATTRIBUTE_READONLY);
1081 if (!bOpenWith)
1082 CAppUtils::ShellOpen(tempfile.GetWinPath(), GetSafeHwnd());
1083 else
1084 CAppUtils::ShowOpenWithDialog(tempfile.GetWinPathString(), GetSafeHwnd());
1085 }
1086 }
1087 break;
1088 case ID_BLAME:
1089 {
1090 CBlameDlg dlg;
1091 dlg.EndRev = revSelected;
1092 if (dlg.DoModal() == IDOK)
1093 {
1094 CBlame blame;
1095 CString tempfile;
1096 CString logfile;
1097 tempfile = blame.BlameToTempFile(m_path, dlg.StartRev, dlg.EndRev, dlg.EndRev, logfile, _T(""), dlg.m_bIncludeMerge, TRUE, TRUE);
1098 if (!tempfile.IsEmpty())
1099 {
1100 if (dlg.m_bTextView)
1101 {
1102 //open the default text editor for the result file
1103 CAppUtils::StartTextViewer(tempfile);
1104 }
1105 else
1106 {
1107 CString sParams = _T("/path:\"") + m_path.GetGitPathString() + _T("\" ");
1108 if(!CAppUtils::LaunchTortoiseBlame(tempfile, logfile, CPathUtils::GetFileNameFromPath(m_path.GetFileOrDirectoryName()),sParams))
1109 {
1110 break;
1111 }
1112 }
1113 }
1114 else
1115 {
1116 CMessageBox::Show(this->m_hWnd, blame.GetLastErrorMessage(), _T("TortoiseGit"), MB_ICONERROR);
1117 }
1118 }
1119 }
1120 break;
1121 case ID_EXPORT:
1122 {
1123 CString sCmd;
1124 sCmd.Format(_T("%s /command:export /path:\"%s\" /revision:%ld"),
1125 (LPCTSTR)(CPathUtils::GetAppDirectory()+_T("TortoiseGitProc.exe")),
1126 (LPCTSTR)pathURL, (LONG)revSelected);
1127 CAppUtils::LaunchApplication(sCmd, NULL, false);
1128 }
1129 break;
1130 case ID_VIEWREV:
1131 {
1132 CString url = m_ProjectProperties.sWebViewerRev;
1133 url = GetAbsoluteUrlFromRelativeUrl(url);
1134 url.Replace(_T("%REVISION%"), revSelected.ToString());
1135 if (!url.IsEmpty())
1136 ShellExecute(this->m_hWnd, _T("open"), url, NULL, NULL, SW_SHOWDEFAULT);
1137 }
1138 break;
1139 case ID_VIEWPATHREV:
1140 {
1141 CString relurl = pathURL;
1142 CString sRoot = GetRepositoryRoot(CTGitPath(relurl));
1143 relurl = relurl.Mid(sRoot.GetLength());
1144 CString url = m_ProjectProperties.sWebViewerPathRev;
1145 url = GetAbsoluteUrlFromRelativeUrl(url);
1146 url.Replace(_T("%REVISION%"), revSelected.ToString());
1147 url.Replace(_T("%PATH%"), relurl);
1148 if (!url.IsEmpty())
1149 ShellExecute(this->m_hWnd, _T("open"), url, NULL, NULL, SW_SHOWDEFAULT);
1150 }
1151 break;
1152 #endif
1153
1154 } // switch (cmd)
1155
1156 theApp.DoWaitCursor(-1);
1157 }
1158
1159 void CGitLogList::SetSelectedRebaseAction(int action)
1160 {
1161 POSITION pos = GetFirstSelectedItemPosition();
1162 if (!pos) return;
1163 int index;
1164 while(pos)
1165 {
1166 index = GetNextSelectedItem(pos);
1167 if (((GitRevLoglist*)m_arShownList[index])->GetRebaseAction() & (LOGACTIONS_REBASE_CURRENT | LOGACTIONS_REBASE_DONE) || (index == GetItemCount() - 1 && action == LOGACTIONS_REBASE_SQUASH))
1168 continue;
1169 ((GitRevLoglist*)m_arShownList[index])->GetRebaseAction() = action;
1170 CRect rect;
1171 this->GetItemRect(index,&rect,LVIR_BOUNDS);
1172 this->InvalidateRect(rect);
1173
1174 }
1175 GetParent()->PostMessage(CGitLogListBase::m_RebaseActionMessage);
1176 }
1177
1178 void CGitLogList::SetUnselectedRebaseAction(int action)
1179 {
1180 POSITION pos = GetFirstSelectedItemPosition();
1181 int index = pos ? GetNextSelectedItem(pos) : -1;
1182 for (int i = 0; i < GetItemCount(); i++)
1183 {
1184 if (i == index)
1185 {
1186 index = pos ? GetNextSelectedItem(pos) : -1;
1187 continue;
1188 }
1189
1190 if (((GitRevLoglist*)m_arShownList[i])->GetRebaseAction() & (LOGACTIONS_REBASE_CURRENT | LOGACTIONS_REBASE_DONE) || (i == GetItemCount() - 1 && action == LOGACTIONS_REBASE_SQUASH))
1191 continue;
1192 ((GitRevLoglist*)m_arShownList[i])->GetRebaseAction() = action;
1193 CRect rect;
1194 this->GetItemRect(i, &rect, LVIR_BOUNDS);
1195 this->InvalidateRect(rect);
1196 }
1197
1198 GetParent()->PostMessage(CGitLogListBase::m_RebaseActionMessage);
1199 }
1200
1201 void CGitLogList::ShiftSelectedRebaseAction()
1202 {
1203 POSITION pos = GetFirstSelectedItemPosition();
1204 int index;
1205 while(pos)
1206 {
1207 index = GetNextSelectedItem(pos);
1208 int *action = &((GitRevLoglist*)m_arShownList[index])->GetRebaseAction();
1209 switch (*action)
1210 {
1211 case LOGACTIONS_REBASE_PICK:
1212 *action = LOGACTIONS_REBASE_SKIP;
1213 break;
1214 case LOGACTIONS_REBASE_SKIP:
1215 *action= LOGACTIONS_REBASE_EDIT;
1216 break;
1217 case LOGACTIONS_REBASE_EDIT:
1218 *action = LOGACTIONS_REBASE_SQUASH;
1219 if (index == GetItemCount() - 1)
1220 *action = LOGACTIONS_REBASE_PICK;
1221 break;
1222 case LOGACTIONS_REBASE_SQUASH:
1223 *action= LOGACTIONS_REBASE_PICK;
1224 break;
1225 }
1226 CRect rect;
1227 this->GetItemRect(index, &rect, LVIR_BOUNDS);
1228 this->InvalidateRect(rect);
1229 }
1230 }
Windows Explorer Extension to Operate Git