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