?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Updated libgit2
[TortoiseGit.git] / src / TortoiseProc / GitProgressDlg.cpp
blob02a4fc2366850070993b41af0c0f03c01ca7b027
1 // TortoiseGit - a Windows shell extension for easy version control
2
3 // Copyright (C) 2008-2013 - TortoiseGit
4 // Copyright (C) 2003-2008 - TortoiseSVN
5
6 // This program is free software; you can redistribute it and/or
7 // modify it under the terms of the GNU General Public License
8 // as published by the Free Software Foundation; either version 2
9 // of the License, or (at your option) any later version.
10
11 // This program is distributed in the hope that it will be useful,
12 // but WITHOUT ANY WARRANTY; without even the implied warranty of
13 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 // GNU General Public License for more details.
15
16 // You should have received a copy of the GNU General Public License
17 // along with this program; if not, write to the Free Software Foundation,
18 // 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
19 //
20 #include "stdafx.h"
21 #include "TortoiseProc.h"
22 #include "messagebox.h"
23 #include "GITProgressDlg.h"
24 #include "LogDlg.h"
25 #include "TGitPath.h"
26 #include "registry.h"
27 #include "GitStatus.h"
28 #include "AppUtils.h"
29 #include "PathUtils.h"
30 #include "StringUtils.h"
31 #include "TempFile.h"
32 #include "UnicodeUtils.h"
33 #include "SoundUtils.h"
34 #include "GitDiff.h"
35 #include "Hooks.h"
36 #include "DropFiles.h"
37 //#include "GitLogHelper.h"
38 #include "RegHistory.h"
39 //#include "ConflictResolveDlg.h"
40 #include "LogFile.h"
41 #include "ShellUpdater.h"
42 #include "IconMenu.h"
43 #include "BugTraqAssociations.h"
44 #include "patch.h"
45 #include "MassiveGitTask.h"
46 #include "git2.h"
47 #include "SmartHandle.h"
48
49 static UINT WM_GITPROGRESS = RegisterWindowMessage(_T("TORTOISEGIT_GITPROGRESS_MSG"));
50
51 BOOL CGitProgressDlg::m_bAscending = FALSE;
52 int CGitProgressDlg::m_nSortedColumn = -1;
53
54 #define TRANSFERTIMER 100
55 #define VISIBLETIMER 101
56
57 enum GITProgressDlgContextMenuCommands
58 {
59 // needs to start with 1, since 0 is the return value if *nothing* is clicked on in the context menu
60 ID_COMPARE = 1,
61 ID_EDITCONFLICT,
62 ID_CONFLICTRESOLVE,
63 ID_CONFLICTUSETHEIRS,
64 ID_CONFLICTUSEMINE,
65 ID_LOG,
66 ID_OPEN,
67 ID_OPENWITH,
68 ID_EXPLORE,
69 ID_COPY
70 };
71
72 IMPLEMENT_DYNAMIC(CGitProgressDlg, CResizableStandAloneDialog)
73 CGitProgressDlg::CGitProgressDlg(CWnd* pParent /*=NULL*/)
74 : CResizableStandAloneDialog(CGitProgressDlg::IDD, pParent)
75 , m_bCancelled(FALSE)
76 , m_pThread(NULL)
77 , m_bErrorsOccurred(false)
78 #if 0
79 , m_Revision(_T("HEAD"))
80 //, m_RevisionEnd(0)
81 , m_bLockWarning(false)
82 , m_bLockExists(false)
83 , m_bThreadRunning(FALSE)
84 , m_nConflicts(0)
85 , m_bMergesAddsDeletesOccurred(FALSE)
86
87 , m_options(ProgOptNone)
88 , m_dwCloseOnEnd((DWORD)-1)
89 , m_bFinishedItemAdded(false)
90 , m_bLastVisible(false)
91 // , m_depth(svn_depth_unknown)
92 , m_itemCount(-1)
93 , m_itemCountTotal(-1)
94 , m_AlwaysConflicted(false)
95 , m_BugTraqProvider(NULL)
96 , sDryRun(MAKEINTRESOURCE(IDS_PROGRS_DRYRUN))
97 , sRecordOnly(MAKEINTRESOURCE(IDS_MERGE_RECORDONLY))
98 #endif
99 {
100 }
101
102 CGitProgressDlg::~CGitProgressDlg()
103 {
104 for (size_t i = 0; i < m_arData.size(); ++i)
105 {
106 delete m_arData[i];
107 }
108 if(m_pThread != NULL)
109 {
110 delete m_pThread;
111 }
112 }
113
114 void CGitProgressDlg::DoDataExchange(CDataExchange* pDX)
115 {
116 CResizableStandAloneDialog::DoDataExchange(pDX);
117 DDX_Control(pDX, IDC_SVNPROGRESS, m_ProgList);
118 }
119
120 BEGIN_MESSAGE_MAP(CGitProgressDlg, CResizableStandAloneDialog)
121 ON_BN_CLICKED(IDC_LOGBUTTON, OnBnClickedLogbutton)
122 ON_NOTIFY(NM_CUSTOMDRAW, IDC_SVNPROGRESS, OnNMCustomdrawSvnprogress)
123 ON_WM_CLOSE()
124 ON_NOTIFY(NM_DBLCLK, IDC_SVNPROGRESS, OnNMDblclkSvnprogress)
125 ON_NOTIFY(HDN_ITEMCLICK, 0, OnHdnItemclickSvnprogress)
126 ON_WM_SETCURSOR()
127 ON_WM_CONTEXTMENU()
128 ON_REGISTERED_MESSAGE(WM_GITPROGRESS, OnGitProgress)
129 ON_WM_TIMER()
130 ON_EN_SETFOCUS(IDC_INFOTEXT, &CGitProgressDlg::OnEnSetfocusInfotext)
131 ON_NOTIFY(LVN_BEGINDRAG, IDC_SVNPROGRESS, &CGitProgressDlg::OnLvnBegindragSvnprogress)
132 ON_WM_SIZE()
133 ON_NOTIFY(LVN_GETDISPINFO, IDC_SVNPROGRESS, &CGitProgressDlg::OnLvnGetdispinfoSvnprogress)
134 ON_BN_CLICKED(IDC_NONINTERACTIVE, &CGitProgressDlg::OnBnClickedNoninteractive)
135 ON_MESSAGE(WM_SHOWCONFLICTRESOLVER, OnShowConflictResolver)
136 ON_REGISTERED_MESSAGE(WM_TASKBARBTNCREATED, OnTaskbarBtnCreated)
137 END_MESSAGE_MAP()
138
139 BOOL CGitProgressDlg::Cancel()
140 {
141 return m_bCancelled;
142 }
143
144 LRESULT CGitProgressDlg::OnShowConflictResolver(WPARAM /*wParam*/, LPARAM /*lParam*/)
145 {
146 #if 0
147 CConflictResolveDlg dlg(this);
148 const svn_wc_conflict_description_t *description = (svn_wc_conflict_description_t *)lParam;
149 if (description)
150 {
151 dlg.SetConflictDescription(description);
152 if (m_pTaskbarList)
153 {
154 m_pTaskbarList->SetProgressState(m_hWnd, TBPF_PAUSED);
155 }
156 if (dlg.DoModal() == IDOK)
157 {
158 if (dlg.GetResult() == svn_wc_conflict_choose_postpone)
159 {
160 // if the result is conflicted and the dialog returned IDOK,
161 // that means we should not ask again in case of a conflict
162 m_AlwaysConflicted = true;
163 ::SendMessage(GetDlgItem(IDC_NONINTERACTIVE)->GetSafeHwnd(), BM_SETCHECK, BST_CHECKED, 0);
164 }
165 }
166 m_mergedfile = dlg.GetMergedFile();
167 m_bCancelled = dlg.IsCancelled();
168 if (m_pTaskbarList)
169 m_pTaskbarList->SetProgressState(m_hWnd, TBPF_INDETERMINATE);
170 return dlg.GetResult();
171 }
172
173 return svn_wc_conflict_choose_postpone;
174 #endif
175 return 0;
176 }
177 #if 0
178 svn_wc_conflict_choice_t CGitProgressDlg::ConflictResolveCallback(const svn_wc_conflict_description_t *description, CString& mergedfile)
179 {
180 // we only bother the user when merging
181 if (((m_Command == GitProgress_Merge)||(m_Command == GitProgress_MergeAll)||(m_Command == GitProgress_MergeReintegrate))&&(!m_AlwaysConflicted)&&(description))
182 {
183 // we're in a worker thread here. That means we must not show a dialog from the thread
184 // but let the UI thread do it.
185 // To do that, we send a message to the UI thread and let it show the conflict resolver dialog.
186 LRESULT dlgResult = ::SendMessage(GetSafeHwnd(), WM_SHOWCONFLICTRESOLVER, 0, (LPARAM)description);
187 mergedfile = m_mergedfile;
188 return (svn_wc_conflict_choice_t)dlgResult;
189 }
190
191 return svn_wc_conflict_choose_postpone;
192 }
193 #endif
194 void CGitProgressDlg::AddItemToList()
195 {
196 int totalcount = m_ProgList.GetItemCount();
197
198 m_ProgList.SetItemCountEx(totalcount+1, LVSICF_NOSCROLL|LVSICF_NOINVALIDATEALL);
199 // make columns width fit
200 if (iFirstResized < 30)
201 {
202 // only resize the columns for the first 30 or so entries.
203 // after that, don't resize them anymore because that's an
204 // expensive function call and the columns will be sized
205 // close enough already.
206 ResizeColumns();
207 ++iFirstResized;
208 }
209
210 // Make sure the item is *entirely* visible even if the horizontal
211 // scroll bar is visible.
212 int count = m_ProgList.GetCountPerPage();
213 if (totalcount <= (m_ProgList.GetTopIndex() + count + nEnsureVisibleCount + 2))
214 {
215 ++nEnsureVisibleCount;
216 m_bLastVisible = true;
217 }
218 else
219 {
220 nEnsureVisibleCount = 0;
221 if (IsIconic() == 0)
222 m_bLastVisible = false;
223 }
224 }
225
226
227 BOOL CGitProgressDlg::Notify(const CTGitPath& path, git_wc_notify_action_t action,
228 int /*status*/ ,
229 CString *strErr
230 /*
231 svn_node_kind_t kind, const CString& mime_type,
232 svn_wc_notify_state_t content_state,
233 svn_wc_notify_state_t prop_state, LONG rev,
234 const svn_lock_t * lock, svn_wc_notify_lock_state_t lock_state,
235 const CString& changelistname,
236 svn_merge_range_t * range,
237 svn_error_t * err, apr_pool_t * pool
238 */)
239 {
240 bool bNoNotify = false;
241 bool bDoAddData = true;
242 NotificationData * data = new NotificationData();
243 data->path = path;
244 data->action = action;
245 data->sPathColumnText=path.GetGitPathString();
246 data->bAuxItem = false;
247 #if 0
248 data->kind = kind;
249 data->mime_type = mime_type;
250 data->content_state = content_state;
251 data->prop_state = prop_state;
252 data->rev = rev;
253 data->lock_state = lock_state;
254 data->changelistname = changelistname;
255 if ((lock)&&(lock->owner))
256 data->owner = CUnicodeUtils::GetUnicode(lock->owner);
257 data->sPathColumnText = path.GetUIPathString();
258 if (!m_basePath.IsEmpty())
259 data->basepath = m_basePath;
260 if (range)
261 data->merge_range = *range;
262 #endif
263 switch (data->action)
264 {
265 case git_wc_notify_add:
266 //case svn_wc_notify_update_add:
267 // if ((data->content_state == svn_wc_notify_state_conflicted) || (data->prop_state == svn_wc_notify_state_conflicted))
268 // {
269 // data->color = m_Colors.GetColor(CColors::Conflict);
270 // data->bConflictedActionItem = true;
271 // data->sActionColumnText.LoadString(IDS_SVNACTION_CONFLICTED);
272 // ++m_nConflicts;
273 // }
274 // else
275 // {
276 // m_bMergesAddsDeletesOccurred = true;
277 data->sActionColumnText.LoadString(IDS_SVNACTION_ADD);
278 data->color = m_Colors.GetColor(CColors::Added);
279 // }
280 break;
281 case git_wc_notify_sendmail_start:
282 data->bAuxItem = true;
283 data->sActionColumnText.LoadString(IDS_SVNACTION_SENDMAIL_START);
284 data->color = m_Colors.GetColor(CColors::Modified);
285 break;
286
287 case git_wc_notify_sendmail_error:
288 data->bAuxItem = true;
289 data->sActionColumnText.LoadString(IDS_SVNACTION_SENDMAIL_ERROR);
290 if(strErr)
291 data->sPathColumnText = *strErr;
292 else
293 data->sPathColumnText.Empty();
294 data->color = m_Colors.GetColor(CColors::Modified);
295 break;
296
297 case git_wc_notify_sendmail_done:
298
299 data->sActionColumnText.LoadString(IDS_SVNACTION_SENDMAIL_DONE);
300 data->sPathColumnText.Empty();
301 data->color = m_Colors.GetColor(CColors::Modified);
302 break;
303
304 case git_wc_notify_sendmail_retry:
305 data->sActionColumnText.LoadString(IDS_SVNACTION_SENDMAIL_RETRY);
306 data->sPathColumnText.Empty();
307 data->color = m_Colors.GetColor(CColors::Modified);
308 break;
309
310
311 case git_wc_notify_resolved:
312 data->sActionColumnText.LoadString(IDS_SVNACTION_RESOLVE);
313 break;
314
315 case git_wc_notify_revert:
316 data->sActionColumnText.LoadString(IDS_SVNACTION_REVERT);
317 break;
318
319 #if 0
320 case svn_wc_notify_commit_added:
321 data->sActionColumnText.LoadString(IDS_SVNACTION_ADDING);
322 data->color = m_Colors.GetColor(CColors::Added);
323 break;
324 case svn_wc_notify_copy:
325 data->sActionColumnText.LoadString(IDS_SVNACTION_COPY);
326 break;
327 case svn_wc_notify_commit_modified:
328 data->sActionColumnText.LoadString(IDS_SVNACTION_MODIFIED);
329 data->color = m_Colors.GetColor(CColors::Modified);
330 break;
331 case svn_wc_notify_delete:
332 case svn_wc_notify_update_delete:
333 data->sActionColumnText.LoadString(IDS_SVNACTION_DELETE);
334 m_bMergesAddsDeletesOccurred = true;
335 data->color = m_Colors.GetColor(CColors::Deleted);
336 break;
337 case svn_wc_notify_commit_deleted:
338 data->sActionColumnText.LoadString(IDS_SVNACTION_DELETING);
339 data->color = m_Colors.GetColor(CColors::Deleted);
340 break;
341 case svn_wc_notify_restore:
342 data->sActionColumnText.LoadString(IDS_SVNACTION_RESTORE);
343 break;
344
345 case svn_wc_notify_update_replace:
346 case svn_wc_notify_commit_replaced:
347 data->sActionColumnText.LoadString(IDS_SVNACTION_REPLACED);
348 data->color = m_Colors.GetColor(CColors::Deleted);
349 break;
350 case svn_wc_notify_exists:
351 if ((data->content_state == svn_wc_notify_state_conflicted) || (data->prop_state == svn_wc_notify_state_conflicted))
352 {
353 data->color = m_Colors.GetColor(CColors::Conflict);
354 data->bConflictedActionItem = true;
355 ++m_nConflicts;
356 data->sActionColumnText.LoadString(IDS_SVNACTION_CONFLICTED);
357 }
358 else if ((data->content_state == svn_wc_notify_state_merged) || (data->prop_state == svn_wc_notify_state_merged))
359 {
360 data->color = m_Colors.GetColor(CColors::Merged);
361 m_bMergesAddsDeletesOccurred = true;
362 data->sActionColumnText.LoadString(IDS_SVNACTION_MERGED);
363 }
364 else
365 data->sActionColumnText.LoadString(IDS_SVNACTION_EXISTS);
366 break;
367 case svn_wc_notify_update_update:
368 // if this is an inoperative dir change, don't show the notification.
369 // an inoperative dir change is when a directory gets updated without
370 // any real change in either text or properties.
371 if ((kind == svn_node_dir)
372 && ((prop_state == svn_wc_notify_state_inapplicable)
373 || (prop_state == svn_wc_notify_state_unknown)
374 || (prop_state == svn_wc_notify_state_unchanged)))
375 {
376 bNoNotify = true;
377 break;
378 }
379 if ((data->content_state == svn_wc_notify_state_conflicted) || (data->prop_state == svn_wc_notify_state_conflicted))
380 {
381 data->color = m_Colors.GetColor(CColors::Conflict);
382 data->bConflictedActionItem = true;
383 ++m_nConflicts;
384 data->sActionColumnText.LoadString(IDS_SVNACTION_CONFLICTED);
385 }
386 else if ((data->content_state == svn_wc_notify_state_merged) || (data->prop_state == svn_wc_notify_state_merged))
387 {
388 data->color = m_Colors.GetColor(CColors::Merged);
389 m_bMergesAddsDeletesOccurred = true;
390 data->sActionColumnText.LoadString(IDS_SVNACTION_MERGED);
391 }
392 else if (((data->content_state != svn_wc_notify_state_unchanged)&&(data->content_state != svn_wc_notify_state_unknown)) ||
393 ((data->prop_state != svn_wc_notify_state_unchanged)&&(data->prop_state != svn_wc_notify_state_unknown)))
394 {
395 data->sActionColumnText.LoadString(IDS_SVNACTION_UPDATE);
396 }
397 else
398 {
399 bNoNotify = true;
400 break;
401 }
402 if (lock_state == svn_wc_notify_lock_state_unlocked)
403 {
404 CString temp(MAKEINTRESOURCE(IDS_SVNACTION_UNLOCKED));
405 data->sActionColumnText += _T(", ") + temp;
406 }
407 break;
408
409 case svn_wc_notify_update_external:
410 // For some reason we build a list of externals...
411 m_ExtStack.AddHead(path.GetUIPathString());
412 data->sActionColumnText.LoadString(IDS_SVNACTION_EXTERNAL);
413 data->bAuxItem = true;
414 break;
415
416 case svn_wc_notify_update_completed:
417 {
418 data->sActionColumnText.LoadString(IDS_SVNACTION_COMPLETED);
419 data->bAuxItem = true;
420 bool bEmpty = !!m_ExtStack.IsEmpty();
421 if (!bEmpty)
422 data->sPathColumnText.Format(IDS_PROGRS_PATHATREV, (LPCTSTR)m_ExtStack.RemoveHead(), rev);
423 else
424 data->sPathColumnText.Format(IDS_PROGRS_ATREV, rev);
425
426 if ((m_nConflicts>0)&&(bEmpty))
427 {
428 // We're going to add another aux item - let's shove this current onto the list first
429 // I don't really like this, but it will do for the moment.
430 m_arData.push_back(data);
431 AddItemToList();
432
433 data = new NotificationData();
434 data->bAuxItem = true;
435 data->sActionColumnText.LoadString(IDS_PROGRS_CONFLICTSOCCURED_WARNING);
436 data->sPathColumnText.LoadString(IDS_PROGRS_CONFLICTSOCCURED);
437 data->color = m_Colors.GetColor(CColors::Conflict);
438 CSoundUtils::PlayTSVNWarning();
439 // This item will now be added after the switch statement
440 }
441 if (!m_basePath.IsEmpty())
442 m_FinishedRevMap[m_basePath.GetSVNApiPath(pool)] = rev;
443 m_RevisionEnd = rev;
444 m_bFinishedItemAdded = true;
445 }
446 break;
447 case svn_wc_notify_commit_postfix_txdelta:
448 data->sActionColumnText.LoadString(IDS_SVNACTION_POSTFIX);
449 break;
450 case svn_wc_notify_failed_revert:
451 data->sActionColumnText.LoadString(IDS_SVNACTION_FAILEDREVERT);
452 break;
453 case svn_wc_notify_status_completed:
454 case svn_wc_notify_status_external:
455 data->sActionColumnText.LoadString(IDS_SVNACTION_STATUS);
456 break;
457 case svn_wc_notify_skip:
458 if ((content_state == svn_wc_notify_state_missing)||(content_state == svn_wc_notify_state_obstructed)||(content_state == svn_wc_notify_state_conflicted))
459 {
460 data->sActionColumnText.LoadString(IDS_SVNACTION_SKIPMISSING);
461
462 // The color settings dialog describes the red color with
463 // "possible or real conflict / obstructed" which also applies to
464 // skipped targets during a merge. So we just use the same color.
465 data->color = m_Colors.GetColor(CColors::Conflict);
466 }
467 else
468 data->sActionColumnText.LoadString(IDS_SVNACTION_SKIP);
469 break;
470 case svn_wc_notify_locked:
471 if ((lock)&&(lock->owner))
472 data->sActionColumnText.Format(IDS_SVNACTION_LOCKEDBY, (LPCTSTR)CUnicodeUtils::GetUnicode(lock->owner));
473 break;
474 case svn_wc_notify_unlocked:
475 data->sActionColumnText.LoadString(IDS_SVNACTION_UNLOCKED);
476 break;
477 case svn_wc_notify_failed_lock:
478 data->sActionColumnText.LoadString(IDS_SVNACTION_FAILEDLOCK);
479 m_arData.push_back(data);
480 AddItemToList();
481 ReportError(SVN::GetErrorString(err));
482 bDoAddData = false;
483 if (err->apr_err == SVN_ERR_FS_OUT_OF_DATE)
484 m_bLockWarning = true;
485 if (err->apr_err == SVN_ERR_FS_PATH_ALREADY_LOCKED)
486 m_bLockExists = true;
487 break;
488 case svn_wc_notify_failed_unlock:
489 data->sActionColumnText.LoadString(IDS_SVNACTION_FAILEDUNLOCK);
490 m_arData.push_back(data);
491 AddItemToList();
492 ReportError(SVN::GetErrorString(err));
493 bDoAddData = false;
494 if (err->apr_err == SVN_ERR_FS_OUT_OF_DATE)
495 m_bLockWarning = true;
496 break;
497 case svn_wc_notify_changelist_set:
498 data->sActionColumnText.Format(IDS_SVNACTION_CHANGELISTSET, (LPCTSTR)data->changelistname);
499 break;
500 case svn_wc_notify_changelist_clear:
501 data->sActionColumnText.LoadString(IDS_SVNACTION_CHANGELISTCLEAR);
502 break;
503 case svn_wc_notify_changelist_moved:
504 data->sActionColumnText.Format(IDS_SVNACTION_CHANGELISTMOVED, (LPCTSTR)data->changelistname);
505 break;
506 case svn_wc_notify_foreign_merge_begin:
507 case svn_wc_notify_merge_begin:
508 if (range == NULL)
509 data->sActionColumnText.LoadString(IDS_SVNACTION_MERGEBEGINNONE);
510 else if ((data->merge_range.start == data->merge_range.end) || (data->merge_range.start == data->merge_range.end - 1))
511 data->sActionColumnText.Format(IDS_SVNACTION_MERGEBEGINSINGLE, data->merge_range.end);
512 else if (data->merge_range.start - 1 == data->merge_range.end)
513 data->sActionColumnText.Format(IDS_SVNACTION_MERGEBEGINSINGLEREVERSE, data->merge_range.start);
514 else if (data->merge_range.start < data->merge_range.end)
515 data->sActionColumnText.Format(IDS_SVNACTION_MERGEBEGINMULTIPLE, data->merge_range.start + 1, data->merge_range.end);
516 else
517 data->sActionColumnText.Format(IDS_SVNACTION_MERGEBEGINMULTIPLEREVERSE, data->merge_range.start, data->merge_range.end + 1);
518 data->bAuxItem = true;
519 break;
520 #endif
521 default:
522 break;
523 } // switch (data->action)
524
525 if (bNoNotify)
526 delete data;
527 else
528 {
529 if (bDoAddData)
530 {
531 m_arData.push_back(data);
532 AddItemToList();
533 if ((!data->bAuxItem) && (m_itemCount > 0))
534 {
535 m_itemCount--;
536
537 CProgressCtrl * progControl = (CProgressCtrl *)GetDlgItem(IDC_PROGRESSBAR);
538 progControl->ShowWindow(SW_SHOW);
539 progControl->SetPos(m_itemCountTotal - m_itemCount);
540 progControl->SetRange32(0, m_itemCountTotal);
541 if (m_pTaskbarList)
542 {
543 m_pTaskbarList->SetProgressState(m_hWnd, TBPF_NORMAL);
544 m_pTaskbarList->SetProgressValue(m_hWnd, m_itemCountTotal-m_itemCount, m_itemCountTotal);
545 }
546 }
547 }
548 //if ((action == svn_wc_notify_commit_postfix_txdelta)&&(bSecondResized == FALSE))
549 //{
550 // ResizeColumns();
551 // bSecondResized = TRUE;
552 //}
553 }
554
555 return TRUE;
556 }
557
558
559 CString CGitProgressDlg::BuildInfoString()
560 {
561 CString infotext;
562 if(this->m_Command == GitProgress_Resolve)
563 infotext = _T("You need commit your change after resolve conflict");
564 #if 0
565
566 CString temp;
567 int added = 0;
568 int copied = 0;
569 int deleted = 0;
570 int restored = 0;
571 int reverted = 0;
572 int resolved = 0;
573 int conflicted = 0;
574 int updated = 0;
575 int merged = 0;
576 int modified = 0;
577 int skipped = 0;
578 int replaced = 0;
579
580 for (size_t i=0; i<m_arData.size(); ++i)
581 {
582 const NotificationData * dat = m_arData[i];
583 switch (dat->action)
584 {
585 case svn_wc_notify_add:
586 case svn_wc_notify_update_add:
587 case svn_wc_notify_commit_added:
588 if (dat->bConflictedActionItem)
589 ++conflicted;
590 else
591 ++added;
592 break;
593 case svn_wc_notify_copy:
594 ++copied;
595 break;
596 case svn_wc_notify_delete:
597 case svn_wc_notify_update_delete:
598 case svn_wc_notify_commit_deleted:
599 ++deleted;
600 break;
601 case svn_wc_notify_restore:
602 ++restored;
603 break;
604 case svn_wc_notify_revert:
605 ++reverted;
606 break;
607 case svn_wc_notify_resolved:
608 ++resolved;
609 break;
610 case svn_wc_notify_update_update:
611 if (dat->bConflictedActionItem)
612 ++conflicted;
613 else if ((dat->content_state == svn_wc_notify_state_merged) || (dat->prop_state == svn_wc_notify_state_merged))
614 ++merged;
615 else
616 ++updated;
617 break;
618 case svn_wc_notify_commit_modified:
619 ++modified;
620 break;
621 case svn_wc_notify_skip:
622 ++skipped;
623 break;
624 case svn_wc_notify_commit_replaced:
625 ++replaced;
626 break;
627 }
628 }
629 if (conflicted)
630 {
631 temp.LoadString(IDS_SVNACTION_CONFLICTED);
632 infotext += temp;
633 temp.Format(_T(":%d "), conflicted);
634 infotext += temp;
635 }
636 if (skipped)
637 {
638 temp.LoadString(IDS_SVNACTION_SKIP);
639 infotext += temp;
640 infotext.AppendFormat(_T(":%d "), skipped);
641 }
642 if (merged)
643 {
644 temp.LoadString(IDS_SVNACTION_MERGED);
645 infotext += temp;
646 infotext.AppendFormat(_T(":%d "), merged);
647 }
648 if (added)
649 {
650 temp.LoadString(IDS_SVNACTION_ADD);
651 infotext += temp;
652 infotext.AppendFormat(_T(":%d "), added);
653 }
654 if (deleted)
655 {
656 temp.LoadString(IDS_SVNACTION_DELETE);
657 infotext += temp;
658 infotext.AppendFormat(_T(":%d "), deleted);
659 }
660 if (modified)
661 {
662 temp.LoadString(IDS_SVNACTION_MODIFIED);
663 infotext += temp;
664 infotext.AppendFormat(_T(":%d "), modified);
665 }
666 if (copied)
667 {
668 temp.LoadString(IDS_SVNACTION_COPY);
669 infotext += temp;
670 infotext.AppendFormat(_T(":%d "), copied);
671 }
672 if (replaced)
673 {
674 temp.LoadString(IDS_SVNACTION_REPLACED);
675 infotext += temp;
676 infotext.AppendFormat(_T(":%d "), replaced);
677 }
678 if (updated)
679 {
680 temp.LoadString(IDS_SVNACTION_UPDATE);
681 infotext += temp;
682 infotext.AppendFormat(_T(":%d "), updated);
683 }
684 if (restored)
685 {
686 temp.LoadString(IDS_SVNACTION_RESTORE);
687 infotext += temp;
688 infotext.AppendFormat(_T(":%d "), restored);
689 }
690 if (reverted)
691 {
692 temp.LoadString(IDS_SVNACTION_REVERT);
693 infotext += temp;
694 infotext.AppendFormat(_T(":%d "), reverted);
695 }
696 if (resolved)
697 {
698 temp.LoadString(IDS_SVNACTION_RESOLVE);
699 infotext += temp;
700 infotext.AppendFormat(_T(":%d "), resolved);
701 }
702 #endif
703 return infotext;
704 }
705
706 void CGitProgressDlg::SetSelectedList(const CTGitPathList& selPaths)
707 {
708 m_selectedPaths = selPaths;
709 }
710
711 void CGitProgressDlg::ResizeColumns()
712 {
713 m_ProgList.SetRedraw(FALSE);
714
715 TCHAR textbuf[MAX_PATH];
716
717 int maxcol = ((CHeaderCtrl*)(m_ProgList.GetDlgItem(0)))->GetItemCount()-1;
718 for (int col = 0; col <= maxcol; ++col)
719 {
720 // find the longest width of all items
721 int count = m_ProgList.GetItemCount();
722 HDITEM hdi = {0};
723 hdi.mask = HDI_TEXT;
724 hdi.pszText = textbuf;
725 hdi.cchTextMax = sizeof(textbuf);
726 ((CHeaderCtrl*)(m_ProgList.GetDlgItem(0)))->GetItem(col, &hdi);
727 int cx = m_ProgList.GetStringWidth(hdi.pszText)+20; // 20 pixels for col separator and margin
728
729 for (int index = 0; index<count; ++index)
730 {
731 // get the width of the string and add 12 pixels for the column separator and margins
732 int linewidth = cx;
733 switch (col)
734 {
735 case 0:
736 linewidth = m_ProgList.GetStringWidth(m_arData[index]->sActionColumnText) + 12;
737 break;
738 case 1:
739 linewidth = m_ProgList.GetStringWidth(m_arData[index]->sPathColumnText) + 12;
740 break;
741 }
742 if (cx < linewidth)
743 cx = linewidth;
744 }
745 m_ProgList.SetColumnWidth(col, cx);
746 }
747
748 m_ProgList.SetRedraw(TRUE);
749 }
750
751 BOOL CGitProgressDlg::OnInitDialog()
752 {
753 __super::OnInitDialog();
754
755 // Let the TaskbarButtonCreated message through the UIPI filter. If we don't
756 // do this, Explorer would be unable to send that message to our window if we
757 // were running elevated. It's OK to make the call all the time, since if we're
758 // not elevated, this is a no-op.
759 CHANGEFILTERSTRUCT cfs = { sizeof(CHANGEFILTERSTRUCT) };
760 typedef BOOL STDAPICALLTYPE ChangeWindowMessageFilterExDFN(HWND hWnd, UINT message, DWORD action, PCHANGEFILTERSTRUCT pChangeFilterStruct);
761 CAutoLibrary hUser = AtlLoadSystemLibraryUsingFullPath(_T("user32.dll"));
762 if (hUser)
763 {
764 ChangeWindowMessageFilterExDFN *pfnChangeWindowMessageFilterEx = (ChangeWindowMessageFilterExDFN*)GetProcAddress(hUser, "ChangeWindowMessageFilterEx");
765 if (pfnChangeWindowMessageFilterEx)
766 {
767 pfnChangeWindowMessageFilterEx(m_hWnd, WM_TASKBARBTNCREATED, MSGFLT_ALLOW, &cfs);
768 }
769 }
770 m_pTaskbarList.Release();
771 if (FAILED(m_pTaskbarList.CoCreateInstance(CLSID_TaskbarList)))
772 m_pTaskbarList = nullptr;
773
774 m_ProgList.SetExtendedStyle (LVS_EX_FULLROWSELECT | LVS_EX_DOUBLEBUFFER);
775
776 m_ProgList.DeleteAllItems();
777 int c = ((CHeaderCtrl*)(m_ProgList.GetDlgItem(0)))->GetItemCount()-1;
778 while (c>=0)
779 m_ProgList.DeleteColumn(c--);
780 CString temp;
781 temp.LoadString(IDS_PROGRS_ACTION);
782 m_ProgList.InsertColumn(0, temp);
783 temp.LoadString(IDS_PROGRS_PATH);
784 m_ProgList.InsertColumn(1, temp);
785
786 m_pThread = AfxBeginThread(ProgressThreadEntry, this, THREAD_PRIORITY_NORMAL,0,CREATE_SUSPENDED);
787 if (m_pThread==NULL)
788 {
789 ReportError(CString(MAKEINTRESOURCE(IDS_ERR_THREADSTARTFAILED)));
790 }
791 else
792 {
793 m_pThread->m_bAutoDelete = FALSE;
794 m_pThread->ResumeThread();
795 }
796
797 UpdateData(FALSE);
798
799 // Call this early so that the column headings aren't hidden before any
800 // text gets added.
801 ResizeColumns();
802
803 SetTimer(VISIBLETIMER, 300, NULL);
804
805 AddAnchor(IDC_SVNPROGRESS, TOP_LEFT, BOTTOM_RIGHT);
806 AddAnchor(IDC_PROGRESSLABEL, BOTTOM_LEFT, BOTTOM_CENTER);
807 AddAnchor(IDC_PROGRESSBAR, BOTTOM_CENTER, BOTTOM_RIGHT);
808 AddAnchor(IDC_INFOTEXT, BOTTOM_LEFT, BOTTOM_RIGHT);
809 AddAnchor(IDC_NONINTERACTIVE, BOTTOM_LEFT, BOTTOM_RIGHT);
810 AddAnchor(IDCANCEL, BOTTOM_RIGHT);
811 AddAnchor(IDOK, BOTTOM_RIGHT);
812 AddAnchor(IDC_LOGBUTTON, BOTTOM_RIGHT);
813 //SetPromptParentWindow(this->m_hWnd);
814 if (hWndExplorer)
815 CenterWindow(CWnd::FromHandle(hWndExplorer));
816 EnableSaveRestore(_T("GITProgressDlg"));
817 return TRUE;
818 }
819
820 bool CGitProgressDlg::SetBackgroundImage(UINT nID)
821 {
822 return CAppUtils::SetListCtrlBackgroundImage(m_ProgList.GetSafeHwnd(), nID);
823 }
824
825 void CGitProgressDlg::ReportGitError()
826 {
827 const git_error *err = giterr_last();
828 if (err == nullptr)
829 ReportError(_T("An error occoured in libgit2, but no message is available."));
830 else
831 ReportError(CUnicodeUtils::GetUnicode(giterr_last()->message));
832 }
833
834 void CGitProgressDlg::ReportError(const CString& sError)
835 {
836 CSoundUtils::PlayTGitError();
837 ReportString(sError, CString(MAKEINTRESOURCE(IDS_ERR_ERROR)), m_Colors.GetColor(CColors::Conflict));
838 m_bErrorsOccurred = true;
839 }
840
841 void CGitProgressDlg::ReportWarning(const CString& sWarning)
842 {
843 CSoundUtils::PlayTGitWarning();
844 ReportString(sWarning, CString(MAKEINTRESOURCE(IDS_WARN_WARNING)), m_Colors.GetColor(CColors::Conflict));
845 }
846
847 void CGitProgressDlg::ReportNotification(const CString& sNotification)
848 {
849 CSoundUtils::PlayTGitNotification();
850 ReportString(sNotification, CString(MAKEINTRESOURCE(IDS_WARN_NOTE)));
851 }
852
853 void CGitProgressDlg::ReportCmd(const CString& sCmd)
854 {
855 ReportString(sCmd, CString(MAKEINTRESOURCE(IDS_PROGRS_CMDINFO)), m_Colors.GetColor(CColors::Cmd));
856 }
857
858 void CGitProgressDlg::ReportString(CString sMessage, const CString& sMsgKind, COLORREF color)
859 {
860 // instead of showing a dialog box with the error message or notification,
861 // just insert the error text into the list control.
862 // that way the user isn't 'interrupted' by a dialog box popping up!
863
864 // the message may be split up into different lines
865 // so add a new entry for each line of the message
866 while (!sMessage.IsEmpty())
867 {
868 NotificationData * data = new NotificationData();
869 data->bAuxItem = true;
870 data->sActionColumnText = sMsgKind;
871 if (sMessage.Find('\n')>=0)
872 data->sPathColumnText = sMessage.Left(sMessage.Find('\n'));
873 else
874 data->sPathColumnText = sMessage;
875 data->sPathColumnText.Trim(_T("\n\r"));
876 data->color = color;
877 if (sMessage.Find('\n')>=0)
878 {
879 sMessage = sMessage.Mid(sMessage.Find('\n'));
880 sMessage.Trim(_T("\n\r"));
881 }
882 else
883 sMessage.Empty();
884 m_arData.push_back(data);
885 AddItemToList();
886 }
887 }
888
889 UINT CGitProgressDlg::ProgressThreadEntry(LPVOID pVoid)
890 {
891 return ((CGitProgressDlg*)pVoid)->ProgressThread();
892 }
893
894 UINT CGitProgressDlg::ProgressThread()
895 {
896 // The SetParams function should have loaded something for us
897
898 CString temp;
899 CString sWindowTitle;
900 bool localoperation = false;
901 bool bSuccess = false;
902 m_AlwaysConflicted = false;
903
904 DialogEnableWindow(IDOK, FALSE);
905 DialogEnableWindow(IDCANCEL, TRUE);
906 // SetAndClearProgressInfo(m_hWnd);
907 m_itemCount = m_itemCountTotal;
908
909 InterlockedExchange(&m_bThreadRunning, TRUE);
910 iFirstResized = 0;
911 bSecondResized = FALSE;
912 m_bFinishedItemAdded = false;
913 CTime startTime = CTime::GetCurrentTime();
914
915 if (m_pTaskbarList)
916 m_pTaskbarList->SetProgressState(m_hWnd, TBPF_INDETERMINATE);
917
918 switch (m_Command)
919 {
920 case GitProgress_Add:
921 bSuccess = CmdAdd(sWindowTitle, localoperation);
922 break;
923 case GitProgress_Copy:
924 bSuccess = CmdCopy(sWindowTitle, localoperation);
925 break;
926 case GitProgress_Export:
927 bSuccess = CmdExport(sWindowTitle, localoperation);
928 break;
929 case GitProgress_Rename:
930 bSuccess = CmdRename(sWindowTitle, localoperation);
931 break;
932 case GitProgress_Resolve:
933 bSuccess = CmdResolve(sWindowTitle, localoperation);
934 break;
935 case GitProgress_Revert:
936 bSuccess = CmdRevert(sWindowTitle, localoperation);
937 break;
938 case GitProgress_Switch:
939 bSuccess = CmdSwitch(sWindowTitle, localoperation);
940 break;
941 case GitProgress_SendMail:
942 bSuccess = CmdSendMail(sWindowTitle, localoperation);
943 break;
944 }
945 if (!bSuccess)
946 temp.LoadString(IDS_PROGRS_TITLEFAILED);
947 else
948 temp.LoadString(IDS_PROGRS_TITLEFIN);
949 sWindowTitle = sWindowTitle + _T(" ") + temp;
950 SetWindowText(sWindowTitle);
951
952 KillTimer(TRANSFERTIMER);
953 KillTimer(VISIBLETIMER);
954
955 if (m_pTaskbarList)
956 {
957 if (DidErrorsOccur())
958 {
959 m_pTaskbarList->SetProgressState(m_hWnd, TBPF_ERROR);
960 m_pTaskbarList->SetProgressValue(m_hWnd, 100, 100);
961 }
962 else
963 m_pTaskbarList->SetProgressState(m_hWnd, TBPF_NOPROGRESS);
964 }
965
966 DialogEnableWindow(IDCANCEL, FALSE);
967 DialogEnableWindow(IDOK, TRUE);
968
969 CString info = BuildInfoString();
970 if (!bSuccess)
971 info.LoadString(IDS_PROGRS_INFOFAILED);
972 SetDlgItemText(IDC_INFOTEXT, info);
973 ResizeColumns();
974 CWnd * pWndOk = GetDlgItem(IDOK);
975 if (pWndOk && ::IsWindow(pWndOk->GetSafeHwnd()))
976 {
977 SendMessage(DM_SETDEFID, IDOK);
978 GetDlgItem(IDOK)->SetFocus();
979 }
980
981 CString sFinalInfo;
982 if (!m_sTotalBytesTransferred.IsEmpty())
983 {
984 CTimeSpan time = CTime::GetCurrentTime() - startTime;
985 temp.Format(IDS_PROGRS_TIME, (LONG)time.GetTotalMinutes(), (LONG)time.GetSeconds());
986 sFinalInfo.Format(IDS_PROGRS_FINALINFO, m_sTotalBytesTransferred, (LPCTSTR)temp);
987 SetDlgItemText(IDC_PROGRESSLABEL, sFinalInfo);
988 }
989 else
990 GetDlgItem(IDC_PROGRESSLABEL)->ShowWindow(SW_HIDE);
991
992 GetDlgItem(IDC_PROGRESSBAR)->ShowWindow(SW_HIDE);
993
994 if (!m_bFinishedItemAdded)
995 {
996 // there's no "finished: xxx" line at the end. We add one here to make
997 // sure the user sees that the command is actually finished.
998 NotificationData * data = new NotificationData();
999 data->bAuxItem = true;
1000 data->sActionColumnText.LoadString(IDS_PROGRS_FINISHED);
1001 m_arData.push_back(data);
1002 AddItemToList();
1003 }
1004
1005 int count = m_ProgList.GetItemCount();
1006 if ((count > 0)&&(m_bLastVisible))
1007 m_ProgList.EnsureVisible(count-1, FALSE);
1008
1009 CLogFile logfile;
1010 if (logfile.Open())
1011 {
1012 logfile.AddTimeLine();
1013 for (size_t i = 0; i < m_arData.size(); ++i)
1014 {
1015 NotificationData * data = m_arData[i];
1016 temp.Format(_T("%-20s : %s"), (LPCTSTR)data->sActionColumnText, (LPCTSTR)data->sPathColumnText);
1017 logfile.AddLine(temp);
1018 }
1019 if (!sFinalInfo.IsEmpty())
1020 logfile.AddLine(sFinalInfo);
1021 logfile.Close();
1022 }
1023
1024 m_bCancelled = TRUE;
1025 InterlockedExchange(&m_bThreadRunning, FALSE);
1026 RefreshCursor();
1027
1028 #if 0
1029 DWORD dwAutoClose = CRegStdDWORD(_T("Software\\TortoiseGit\\AutoClose"), CLOSE_MANUAL);
1030 if (m_options & ProgOptDryRun)
1031 dwAutoClose = 0; // dry run means progress dialog doesn't auto close at all
1032 if (!m_bLastVisible)
1033 dwAutoClose = 0;
1034 if (m_dwCloseOnEnd != (DWORD)-1)
1035 dwAutoClose = m_dwCloseOnEnd; // command line value has priority over setting value
1036 if ((dwAutoClose == CLOSE_NOERRORS)&&(!m_bErrorsOccurred))
1037 PostMessage(WM_COMMAND, 1, (LPARAM)GetDlgItem(IDOK)->m_hWnd);
1038 if ((dwAutoClose == CLOSE_NOCONFLICTS)&&(!m_bErrorsOccurred)&&(m_nConflicts==0))
1039 PostMessage(WM_COMMAND, 1, (LPARAM)GetDlgItem(IDOK)->m_hWnd);
1040 if ((dwAutoClose == CLOSE_NOMERGES)&&(!m_bErrorsOccurred)&&(m_nConflicts==0)&&(!m_bMergesAddsDeletesOccurred))
1041 PostMessage(WM_COMMAND, 1, (LPARAM)GetDlgItem(IDOK)->m_hWnd);
1042 if ((dwAutoClose == CLOSE_LOCAL)&&(!m_bErrorsOccurred)&&(m_nConflicts==0)&&(localoperation))
1043 PostMessage(WM_COMMAND, 1, (LPARAM)GetDlgItem(IDOK)->m_hWnd);
1044 #endif
1045
1046 //Don't do anything here which might cause messages to be sent to the window
1047 //The window thread is probably now blocked in OnOK if we've done an auto close
1048 return 0;
1049 }
1050
1051 void CGitProgressDlg::OnBnClickedLogbutton()
1052 {
1053 switch(this->m_Command)
1054 {
1055 case GitProgress_Add:
1056 case GitProgress_Resolve:
1057 {
1058 CString cmd = _T(" /command:commit");
1059 cmd += _T(" /path:\"")+g_Git.m_CurrentDir+_T("\"");
1060
1061 CAppUtils::RunTortoiseGitProc(cmd);
1062 this->EndDialog(IDOK);
1063 break;
1064 }
1065 }
1066 #if 0
1067 if (m_targetPathList.GetCount() != 1)
1068 return;
1069 StringRevMap::iterator it = m_UpdateStartRevMap.begin();
1070 svn_revnum_t rev = -1;
1071 if (it != m_UpdateStartRevMap.end())
1072 {
1073 rev = it->second;
1074 }
1075 CLogDlg dlg;
1076 dlg.SetParams(m_targetPathList[0], m_RevisionEnd, m_RevisionEnd, rev, 0, TRUE);
1077 dlg.DoModal();
1078 #endif
1079 }
1080
1081
1082 void CGitProgressDlg::OnClose()
1083 {
1084 if (m_bCancelled)
1085 {
1086 TerminateThread(m_pThread->m_hThread, (DWORD)-1);
1087 InterlockedExchange(&m_bThreadRunning, FALSE);
1088 }
1089 else
1090 {
1091 m_bCancelled = TRUE;
1092 return;
1093 }
1094 DialogEnableWindow(IDCANCEL, TRUE);
1095 __super::OnClose();
1096 }
1097
1098 void CGitProgressDlg::OnOK()
1099 {
1100 if ((m_bCancelled)&&(!m_bThreadRunning))
1101 {
1102 // I have made this wait a sensible amount of time (10 seconds) for the thread to finish
1103 // You must be careful in the thread that after posting the WM_COMMAND/IDOK message, you
1104 // don't do any more operations on the window which might require message passing
1105 // If you try to send windows messages once we're waiting here, then the thread can't finished
1106 // because the Window's message loop is blocked at this wait
1107 WaitForSingleObject(m_pThread->m_hThread, 10000);
1108 __super::OnOK();
1109 }
1110 m_bCancelled = TRUE;
1111 }
1112
1113 void CGitProgressDlg::OnCancel()
1114 {
1115 if ((m_bCancelled)&&(!m_bThreadRunning))
1116 __super::OnCancel();
1117 m_bCancelled = TRUE;
1118 }
1119
1120 void CGitProgressDlg::OnLvnGetdispinfoSvnprogress(NMHDR *pNMHDR, LRESULT *pResult)
1121 {
1122 NMLVDISPINFO *pDispInfo = reinterpret_cast<NMLVDISPINFO*>(pNMHDR);
1123
1124 if (pDispInfo)
1125 {
1126 if (pDispInfo->item.mask & LVIF_TEXT)
1127 {
1128 if (pDispInfo->item.iItem < (int)m_arData.size())
1129 {
1130 const NotificationData * data = m_arData[pDispInfo->item.iItem];
1131 switch (pDispInfo->item.iSubItem)
1132 {
1133 case 0:
1134 lstrcpyn(m_columnbuf, data->sActionColumnText, MAX_PATH);
1135 break;
1136 case 1:
1137 lstrcpyn(m_columnbuf, data->sPathColumnText, pDispInfo->item.cchTextMax);
1138 if (!data->bAuxItem)
1139 {
1140 int cWidth = m_ProgList.GetColumnWidth(1);
1141 cWidth = max(12, cWidth-12);
1142 CDC * pDC = m_ProgList.GetDC();
1143 if (pDC != NULL)
1144 {
1145 CFont * pFont = pDC->SelectObject(m_ProgList.GetFont());
1146 PathCompactPath(pDC->GetSafeHdc(), m_columnbuf, cWidth);
1147 pDC->SelectObject(pFont);
1148 ReleaseDC(pDC);
1149 }
1150 }
1151 break;
1152 default:
1153 m_columnbuf[0] = 0;
1154 }
1155 pDispInfo->item.pszText = m_columnbuf;
1156 }
1157 }
1158 }
1159 *pResult = 0;
1160 }
1161
1162 void CGitProgressDlg::OnNMCustomdrawSvnprogress(NMHDR *pNMHDR, LRESULT *pResult)
1163 {
1164 NMLVCUSTOMDRAW* pLVCD = reinterpret_cast<NMLVCUSTOMDRAW*>( pNMHDR );
1165
1166 // Take the default processing unless we set this to something else below.
1167 *pResult = CDRF_DODEFAULT;
1168
1169 // First thing - check the draw stage. If it's the control's prepaint
1170 // stage, then tell Windows we want messages for every item.
1171
1172 if ( CDDS_PREPAINT == pLVCD->nmcd.dwDrawStage )
1173 {
1174 *pResult = CDRF_NOTIFYITEMDRAW;
1175 }
1176 else if ( CDDS_ITEMPREPAINT == pLVCD->nmcd.dwDrawStage )
1177 {
1178 // This is the prepaint stage for an item. Here's where we set the
1179 // item's text color. Our return value will tell Windows to draw the
1180 // item itself, but it will use the new color we set here.
1181
1182 // Tell Windows to paint the control itself.
1183 *pResult = CDRF_DODEFAULT;
1184
1185 ASSERT(pLVCD->nmcd.dwItemSpec < m_arData.size());
1186 if(pLVCD->nmcd.dwItemSpec >= m_arData.size())
1187 {
1188 return;
1189 }
1190 const NotificationData * data = m_arData[pLVCD->nmcd.dwItemSpec];
1191 ASSERT(data != NULL);
1192 if (data == NULL)
1193 return;
1194
1195 // Store the color back in the NMLVCUSTOMDRAW struct.
1196 pLVCD->clrText = data->color;
1197 }
1198 }
1199
1200 void CGitProgressDlg::OnNMDblclkSvnprogress(NMHDR * /*pNMHDR*/, LRESULT * /*pResult*/)
1201 {
1202 #if 0
1203 LPNMLISTVIEW pNMLV = reinterpret_cast<LPNMLISTVIEW>(pNMHDR);
1204 *pResult = 0;
1205 if (pNMLV->iItem < 0)
1206 return;
1207 if (m_options & ProgOptDryRun)
1208 return; //don't do anything in a dry-run.
1209
1210 const NotificationData * data = m_arData[pNMLV->iItem];
1211 if (data == NULL)
1212 return;
1213
1214 if (data->bConflictedActionItem)
1215 {
1216 // We've double-clicked on a conflicted item - do a three-way merge on it
1217 SVNDiff::StartConflictEditor(data->path);
1218 }
1219 else if ((data->action == svn_wc_notify_update_update) && ((data->content_state == svn_wc_notify_state_merged)||(GitProgress_Merge == m_Command)) || (data->action == svn_wc_notify_resolved))
1220 {
1221 // This is a modified file which has been merged on update. Diff it against base
1222 CTGitPath temporaryFile;
1223 SVNDiff diff(this, this->m_hWnd, true);
1224 diff.SetAlternativeTool(!!(GetAsyncKeyState(VK_SHIFT) & 0x8000));
1225 svn_revnum_t baseRev = 0;
1226 diff.DiffFileAgainstBase(data->path, baseRev);
1227 }
1228 else if ((!data->bAuxItem)&&(data->path.Exists())&&(!data->path.IsDirectory()))
1229 {
1230 bool bOpenWith = false;
1231 int ret = (int)ShellExecute(m_hWnd, NULL, data->path.GetWinPath(), NULL, NULL, SW_SHOWNORMAL);
1232 if (ret <= HINSTANCE_ERROR)
1233 bOpenWith = true;
1234 if (bOpenWith)
1235 {
1236 CString cmd = _T("RUNDLL32 Shell32,OpenAs_RunDLL ");
1237 cmd += data->path.GetWinPathString() + _T(" ");
1238 CAppUtils::LaunchApplication(cmd, NULL, false);
1239 }
1240 }
1241 #endif
1242 }
1243
1244 void CGitProgressDlg::OnHdnItemclickSvnprogress(NMHDR *pNMHDR, LRESULT *pResult)
1245 {
1246 LPNMHEADER phdr = reinterpret_cast<LPNMHEADER>(pNMHDR);
1247 if (m_bThreadRunning)
1248 return;
1249 if (m_nSortedColumn == phdr->iItem)
1250 m_bAscending = !m_bAscending;
1251 else
1252 m_bAscending = TRUE;
1253 m_nSortedColumn = phdr->iItem;
1254 Sort();
1255
1256 CString temp;
1257 m_ProgList.SetRedraw(FALSE);
1258 m_ProgList.DeleteAllItems();
1259 m_ProgList.SetItemCountEx (static_cast<int>(m_arData.size()));
1260
1261 m_ProgList.SetRedraw(TRUE);
1262
1263 *pResult = 0;
1264 }
1265
1266 bool CGitProgressDlg::NotificationDataIsAux(const NotificationData* pData)
1267 {
1268 return pData->bAuxItem;
1269 }
1270
1271 LRESULT CGitProgressDlg::OnGitProgress(WPARAM /*wParam*/, LPARAM /*lParam*/)
1272 {
1273 #if 0
1274 SVNProgress * pProgressData = (SVNProgress *)lParam;
1275 CProgressCtrl * progControl = (CProgressCtrl *)GetDlgItem(IDC_PROGRESSBAR);
1276 if ((pProgressData->total > 1000)&&(!progControl->IsWindowVisible()))
1277 {
1278 progControl->ShowWindow(SW_SHOW);
1279 if (m_pTaskbarList)
1280 m_pTaskbarList->SetProgressState(m_hWnd, TBPF_NORMAL);
1281 }
1282 if (((pProgressData->total < 0)&&(pProgressData->progress > 1000)&&(progControl->IsWindowVisible()))&&(m_itemCountTotal<0))
1283 {
1284 progControl->ShowWindow(SW_HIDE);
1285 if (m_pTaskbarList)
1286 m_pTaskbarList->SetProgressState(m_hWnd, TBPF_INDETERMINATE);
1287 }
1288 if (!GetDlgItem(IDC_PROGRESSLABEL)->IsWindowVisible())
1289 GetDlgItem(IDC_PROGRESSLABEL)->ShowWindow(SW_SHOW);
1290 SetTimer(TRANSFERTIMER, 2000, NULL);
1291 if ((pProgressData->total > 0)&&(pProgressData->progress > 1000))
1292 {
1293 progControl->SetPos((int)pProgressData->progress);
1294 progControl->SetRange32(0, (int)pProgressData->total);
1295 if (m_pTaskbarList)
1296 {
1297 m_pTaskbarList->SetProgressState(m_hWnd, TBPF_NORMAL);
1298 m_pTaskbarList->SetProgressValue(m_hWnd, pProgressData->progress, pProgressData->total);
1299 }
1300 }
1301 CString progText;
1302 if (pProgressData->overall_total < 1024)
1303 m_sTotalBytesTransferred.Format(IDS_SVN_PROGRESS_TOTALBYTESTRANSFERRED, pProgressData->overall_total);
1304 else if (pProgressData->overall_total < 1200000)
1305 m_sTotalBytesTransferred.Format(IDS_SVN_PROGRESS_TOTALTRANSFERRED, pProgressData->overall_total / 1024);
1306 else
1307 m_sTotalBytesTransferred.Format(IDS_SVN_PROGRESS_TOTALMBTRANSFERRED, (double)((double)pProgressData->overall_total / 1024000.0));
1308 progText.Format(IDS_SVN_PROGRESS_TOTALANDSPEED, (LPCTSTR)m_sTotalBytesTransferred, (LPCTSTR)pProgressData->SpeedString);
1309 SetDlgItemText(IDC_PROGRESSLABEL, progText);
1310 #endif
1311 return 0;
1312 }
1313
1314 void CGitProgressDlg::OnTimer(UINT_PTR nIDEvent)
1315 {
1316 if (nIDEvent == TRANSFERTIMER)
1317 {
1318 CString progText;
1319 CString progSpeed;
1320 progSpeed.Format(IDS_SVN_PROGRESS_BYTES_SEC, 0);
1321 progText.Format(IDS_SVN_PROGRESS_TOTALANDSPEED, (LPCTSTR)m_sTotalBytesTransferred, (LPCTSTR)progSpeed);
1322 SetDlgItemText(IDC_PROGRESSLABEL, progText);
1323 KillTimer(TRANSFERTIMER);
1324 }
1325 if (nIDEvent == VISIBLETIMER)
1326 {
1327 if (nEnsureVisibleCount)
1328 m_ProgList.EnsureVisible(m_ProgList.GetItemCount()-1, false);
1329 nEnsureVisibleCount = 0;
1330 }
1331 }
1332
1333 void CGitProgressDlg::Sort()
1334 {
1335 if(m_arData.size() < 2)
1336 {
1337 return;
1338 }
1339
1340 // We need to sort the blocks which lie between the auxiliary entries
1341 // This is so that any aux data stays where it was
1342 NotificationDataVect::iterator actionBlockBegin;
1343 NotificationDataVect::iterator actionBlockEnd = m_arData.begin(); // We start searching from here
1344
1345 for(;;)
1346 {
1347 // Search to the start of the non-aux entry in the next block
1348 actionBlockBegin = std::find_if(actionBlockEnd, m_arData.end(), std::not1(std::ptr_fun(&CGitProgressDlg::NotificationDataIsAux)));
1349 if(actionBlockBegin == m_arData.end())
1350 {
1351 // There are no more actions
1352 break;
1353 }
1354 // Now search to find the end of the block
1355 actionBlockEnd = std::find_if(actionBlockBegin+1, m_arData.end(), std::ptr_fun(&CGitProgressDlg::NotificationDataIsAux));
1356 // Now sort the block
1357 std::sort(actionBlockBegin, actionBlockEnd, &CGitProgressDlg::SortCompare);
1358 }
1359 }
1360
1361 bool CGitProgressDlg::SortCompare(const NotificationData * pData1, const NotificationData * pData2)
1362 {
1363 int result = 0;
1364 switch (m_nSortedColumn)
1365 {
1366 case 0: //action column
1367 result = pData1->sActionColumnText.Compare(pData2->sActionColumnText);
1368 break;
1369 case 1: //path column
1370 // Compare happens after switch()
1371 break;
1372 default:
1373 break;
1374 }
1375
1376 // Sort by path if everything else is equal
1377 if (result == 0)
1378 {
1379 result = CTGitPath::Compare(pData1->path, pData2->path);
1380 }
1381
1382 if (!m_bAscending)
1383 result = -result;
1384 return result < 0;
1385 }
1386
1387 BOOL CGitProgressDlg::OnSetCursor(CWnd* pWnd, UINT nHitTest, UINT message)
1388 {
1389 if (!GetDlgItem(IDOK)->IsWindowEnabled())
1390 {
1391 // only show the wait cursor over the list control
1392 if ((pWnd)&&(pWnd == GetDlgItem(IDC_SVNPROGRESS)))
1393 {
1394 HCURSOR hCur = LoadCursor(NULL, MAKEINTRESOURCE(IDC_WAIT));
1395 SetCursor(hCur);
1396 return TRUE;
1397 }
1398 }
1399 HCURSOR hCur = LoadCursor(NULL, MAKEINTRESOURCE(IDC_ARROW));
1400 SetCursor(hCur);
1401 return CResizableStandAloneDialog::OnSetCursor(pWnd, nHitTest, message);
1402 }
1403
1404 BOOL CGitProgressDlg::PreTranslateMessage(MSG* pMsg)
1405 {
1406 if (pMsg->message == WM_KEYDOWN)
1407 {
1408 if (pMsg->wParam == VK_ESCAPE)
1409 {
1410 // pressing the ESC key should close the dialog. But since we disabled the escape
1411 // key (so the user doesn't get the idea that he could simply undo an e.g. update)
1412 // this won't work.
1413 // So if the user presses the ESC key, change it to VK_RETURN so the dialog gets
1414 // the impression that the OK button was pressed.
1415 if ((!m_bThreadRunning)&&(!GetDlgItem(IDCANCEL)->IsWindowEnabled())
1416 &&(GetDlgItem(IDOK)->IsWindowEnabled())&&(GetDlgItem(IDOK)->IsWindowVisible()))
1417 {
1418 // since we convert ESC to RETURN, make sure the OK button has the focus.
1419 GetDlgItem(IDOK)->SetFocus();
1420 pMsg->wParam = VK_RETURN;
1421 }
1422 }
1423 if (pMsg->wParam == 'A')
1424 {
1425 if (GetKeyState(VK_CONTROL)&0x8000)
1426 {
1427 // Ctrl-A -> select all
1428 m_ProgList.SetSelectionMark(0);
1429 for (int i=0; i<m_ProgList.GetItemCount(); ++i)
1430 {
1431 m_ProgList.SetItemState(i, LVIS_SELECTED, LVIS_SELECTED);
1432 }
1433 }
1434 }
1435 if ((pMsg->wParam == 'C')||(pMsg->wParam == VK_INSERT))
1436 {
1437 int selIndex = m_ProgList.GetSelectionMark();
1438 if (selIndex >= 0)
1439 {
1440 if (GetKeyState(VK_CONTROL)&0x8000)
1441 {
1442 //Ctrl-C -> copy to clipboard
1443 CString sClipdata;
1444 POSITION pos = m_ProgList.GetFirstSelectedItemPosition();
1445 if (pos != NULL)
1446 {
1447 while (pos)
1448 {
1449 int nItem = m_ProgList.GetNextSelectedItem(pos);
1450 CString sAction = m_ProgList.GetItemText(nItem, 0);
1451 CString sPath = m_ProgList.GetItemText(nItem, 1);
1452 CString sMime = m_ProgList.GetItemText(nItem, 2);
1453 CString sLogCopyText;
1454 sLogCopyText.Format(_T("%s: %s %s\r\n"),
1455 (LPCTSTR)sAction, (LPCTSTR)sPath, (LPCTSTR)sMime);
1456 sClipdata += sLogCopyText;
1457 }
1458 CStringUtils::WriteAsciiStringToClipboard(sClipdata);
1459 }
1460 }
1461 }
1462 }
1463 } // if (pMsg->message == WM_KEYDOWN)
1464 return __super::PreTranslateMessage(pMsg);
1465 }
1466
1467 void CGitProgressDlg::OnContextMenu(CWnd* /*pWnd*/, CPoint /*point*/)
1468 {
1469 #if 0
1470 if (m_options & ProgOptDryRun)
1471 return; // don't do anything in a dry-run.
1472
1473 if (pWnd == &m_ProgList)
1474 {
1475 int selIndex = m_ProgList.GetSelectionMark();
1476 if ((point.x == -1) && (point.y == -1))
1477 {
1478 // Menu was invoked from the keyboard rather than by right-clicking
1479 CRect rect;
1480 m_ProgList.GetItemRect(selIndex, &rect, LVIR_LABEL);
1481 m_ProgList.ClientToScreen(&rect);
1482 point = rect.CenterPoint();
1483 }
1484
1485 if ((selIndex >= 0)&&(!m_bThreadRunning))
1486 {
1487 // entry is selected, thread has finished with updating so show the popup menu
1488 CIconMenu popup;
1489 if (popup.CreatePopupMenu())
1490 {
1491 bool bAdded = false;
1492 NotificationData * data = m_arData[selIndex];
1493 if ((data)&&(!data->path.IsDirectory()))
1494 {
1495 if (data->action == svn_wc_notify_update_update || data->action == svn_wc_notify_resolved)
1496 {
1497 if (m_ProgList.GetSelectedCount() == 1)
1498 {
1499 popup.AppendMenuIcon(ID_COMPARE, IDS_LOG_POPUP_COMPARE, IDI_DIFF);
1500 bAdded = true;
1501 }
1502 }
1503 if (data->bConflictedActionItem)
1504 {
1505 if (m_ProgList.GetSelectedCount() == 1)
1506 {
1507 popup.AppendMenuIcon(ID_EDITCONFLICT, IDS_MENUCONFLICT,IDI_CONFLICT);
1508 popup.SetDefaultItem(ID_EDITCONFLICT, FALSE);
1509 popup.AppendMenuIcon(ID_CONFLICTRESOLVE, IDS_SVNPROGRESS_MENUMARKASRESOLVED,IDI_RESOLVE);
1510 }
1511 popup.AppendMenuIcon(ID_CONFLICTUSETHEIRS, IDS_SVNPROGRESS_MENUUSETHEIRS,IDI_RESOLVE);
1512 popup.AppendMenuIcon(ID_CONFLICTUSEMINE, IDS_SVNPROGRESS_MENUUSEMINE,IDI_RESOLVE);
1513 }
1514 else if ((data->content_state == svn_wc_notify_state_merged)||(GitProgress_Merge == m_Command)||(data->action == svn_wc_notify_resolved))
1515 popup.SetDefaultItem(ID_COMPARE, FALSE);
1516
1517 if (m_ProgList.GetSelectedCount() == 1)
1518 {
1519 if ((data->action == svn_wc_notify_add)||
1520 (data->action == svn_wc_notify_update_add)||
1521 (data->action == svn_wc_notify_commit_added)||
1522 (data->action == svn_wc_notify_commit_modified)||
1523 (data->action == svn_wc_notify_restore)||
1524 (data->action == svn_wc_notify_revert)||
1525 (data->action == svn_wc_notify_resolved)||
1526 (data->action == svn_wc_notify_commit_replaced)||
1527 (data->action == svn_wc_notify_commit_modified)||
1528 (data->action == svn_wc_notify_commit_postfix_txdelta)||
1529 (data->action == svn_wc_notify_update_update))
1530 {
1531 popup.AppendMenuIcon(ID_LOG, IDS_MENULOG,IDI_LOG);
1532 if (data->action == svn_wc_notify_update_update)
1533 popup.AppendMenu(MF_SEPARATOR, NULL);
1534 popup.AppendMenuIcon(ID_OPEN, IDS_LOG_POPUP_OPEN, IDI_OPEN);
1535 popup.AppendMenuIcon(ID_OPENWITH, IDS_LOG_POPUP_OPENWITH, IDI_OPEN);
1536 bAdded = true;
1537 }
1538 }
1539 } // if ((data)&&(!data->path.IsDirectory()))
1540 if (m_ProgList.GetSelectedCount() == 1)
1541 {
1542 if (data)
1543 {
1544 CString sPath = GetPathFromColumnText(data->sPathColumnText);
1545 if ((!sPath.IsEmpty())&&(!SVN::PathIsURL(CTGitPath(sPath))))
1546 {
1547 CTGitPath path = CTGitPath(sPath);
1548 if (path.GetDirectory().Exists())
1549 {
1550 popup.AppendMenuIcon(ID_EXPLORE, IDS_SVNPROGRESS_MENUOPENPARENT, IDI_EXPLORER);
1551 bAdded = true;
1552 }
1553 }
1554 }
1555 }
1556 if (m_ProgList.GetSelectedCount() > 0)
1557 {
1558 if (bAdded)
1559 popup.AppendMenu(MF_SEPARATOR, NULL);
1560 popup.AppendMenuIcon(ID_COPY, IDS_LOG_POPUP_COPYTOCLIPBOARD,IDI_COPYCLIP);
1561 bAdded = true;
1562 }
1563 if (bAdded)
1564 {
1565 int cmd = popup.TrackPopupMenu(TPM_RETURNCMD | TPM_LEFTALIGN | TPM_NONOTIFY, point.x, point.y, this, 0);
1566 DialogEnableWindow(IDOK, FALSE);
1567 this->SetPromptApp(&theApp);
1568 theApp.DoWaitCursor(1);
1569 bool bOpenWith = false;
1570 switch (cmd)
1571 {
1572 case ID_COPY:
1573 {
1574 CString sLines;
1575 POSITION pos = m_ProgList.GetFirstSelectedItemPosition();
1576 while (pos)
1577 {
1578 int nItem = m_ProgList.GetNextSelectedItem(pos);
1579 NotificationData * data = m_arData[nItem];
1580 if (data)
1581 {
1582 sLines += data->sPathColumnText;
1583 sLines += _T("\r\n");
1584 }
1585 }
1586 sLines.TrimRight();
1587 if (!sLines.IsEmpty())
1588 {
1589 CStringUtils::WriteAsciiStringToClipboard(sLines, GetSafeHwnd());
1590 }
1591 }
1592 break;
1593 case ID_EXPLORE:
1594 {
1595 CString sPath = GetPathFromColumnText(data->sPathColumnText);
1596
1597 CTGitPath path = CTGitPath(sPath);
1598 ShellExecute(m_hWnd, _T("explore"), path.GetDirectory().GetWinPath(), NULL, path.GetDirectory().GetWinPath(), SW_SHOW);
1599 }
1600 break;
1601 case ID_COMPARE:
1602 {
1603 svn_revnum_t rev = -1;
1604 StringRevMap::iterator it = m_UpdateStartRevMap.end();
1605 if (data->basepath.IsEmpty())
1606 it = m_UpdateStartRevMap.begin();
1607 else
1608 it = m_UpdateStartRevMap.find(data->basepath.GetSVNApiPath(pool));
1609 if (it != m_UpdateStartRevMap.end())
1610 rev = it->second;
1611 // if the file was merged during update, do a three way diff between OLD, MINE, THEIRS
1612 if (data->content_state == svn_wc_notify_state_merged)
1613 {
1614 CTGitPath basefile = CTempFiles::Instance().GetTempFilePath(false, data->path, rev);
1615 CTGitPath newfile = CTempFiles::Instance().GetTempFilePath(false, data->path, SVNRev::REV_HEAD);
1616 SVN svn;
1617 if (!svn.Cat(data->path, SVNRev(SVNRev::REV_WC), rev, basefile))
1618 {
1619 CMessageBox::Show(m_hWnd, svn.GetLastErrorMessage(), _T("TortoiseGit"), MB_ICONERROR);
1620 DialogEnableWindow(IDOK, TRUE);
1621 break;
1622 }
1623 // If necessary, convert the line-endings on the file before diffing
1624 if ((DWORD)CRegDWORD(_T("Software\\TortoiseGit\\ConvertBase"), TRUE))
1625 {
1626 CTGitPath temporaryFile = CTempFiles::Instance().GetTempFilePath(false, data->path, SVNRev::REV_BASE);
1627 if (!svn.Cat(data->path, SVNRev(SVNRev::REV_BASE), SVNRev(SVNRev::REV_BASE), temporaryFile))
1628 {
1629 temporaryFile.Reset();
1630 break;
1631 }
1632 else
1633 {
1634 newfile = temporaryFile;
1635 }
1636 }
1637
1638 SetFileAttributes(newfile.GetWinPath(), FILE_ATTRIBUTE_READONLY);
1639 SetFileAttributes(basefile.GetWinPath(), FILE_ATTRIBUTE_READONLY);
1640 CString revname, wcname, basename;
1641 revname.Format(_T("%s Revision %ld"), (LPCTSTR)data->path.GetUIFileOrDirectoryName(), rev);
1642 wcname.Format(IDS_DIFF_WCNAME, (LPCTSTR)data->path.GetUIFileOrDirectoryName());
1643 basename.Format(IDS_DIFF_BASENAME, (LPCTSTR)data->path.GetUIFileOrDirectoryName());
1644 CAppUtils::StartExtMerge(basefile, newfile, data->path, data->path, basename, revname, wcname, CString(), true);
1645 }
1646 else
1647 {
1648 CTGitPath tempfile = CTempFiles::Instance().GetTempFilePath(false, data->path, rev);
1649 SVN svn;
1650 if (!svn.Cat(data->path, SVNRev(SVNRev::REV_WC), rev, tempfile))
1651 {
1652 CMessageBox::Show(m_hWnd, svn.GetLastErrorMessage(), _T("TortoiseGit"), MB_ICONERROR);
1653 DialogEnableWindow(IDOK, TRUE);
1654 break;
1655 }
1656 else
1657 {
1658 SetFileAttributes(tempfile.GetWinPath(), FILE_ATTRIBUTE_READONLY);
1659 CString revname, wcname;
1660 revname.Format(_T("%s Revision %ld"), (LPCTSTR)data->path.GetUIFileOrDirectoryName(), rev);
1661 wcname.Format(IDS_DIFF_WCNAME, (LPCTSTR)data->path.GetUIFileOrDirectoryName());
1662 CAppUtils::StartExtDiff(
1663 tempfile, data->path, revname, wcname,
1664 CAppUtils::DiffFlags().AlternativeTool(!!(GetAsyncKeyState(VK_SHIFT) & 0x8000)));
1665 }
1666 }
1667 }
1668 break;
1669 case ID_EDITCONFLICT:
1670 {
1671 CString sPath = GetPathFromColumnText(data->sPathColumnText);
1672 SVNDiff::StartConflictEditor(CTGitPath(sPath));
1673 }
1674 break;
1675 case ID_CONFLICTUSETHEIRS:
1676 case ID_CONFLICTUSEMINE:
1677 case ID_CONFLICTRESOLVE:
1678 {
1679 svn_wc_conflict_choice_t result = svn_wc_conflict_choose_merged;
1680 switch (cmd)
1681 {
1682 case ID_CONFLICTUSETHEIRS:
1683 result = svn_wc_conflict_choose_theirs_full;
1684 break;
1685 case ID_CONFLICTUSEMINE:
1686 result = svn_wc_conflict_choose_mine_full;
1687 break;
1688 case ID_CONFLICTRESOLVE:
1689 result = svn_wc_conflict_choose_merged;
1690 break;
1691 }
1692 SVN svn;
1693 POSITION pos = m_ProgList.GetFirstSelectedItemPosition();
1694 CString sResolvedPaths;
1695 while (pos)
1696 {
1697 int nItem = m_ProgList.GetNextSelectedItem(pos);
1698 NotificationData * data = m_arData[nItem];
1699 if (data)
1700 {
1701 if (data->bConflictedActionItem)
1702 {
1703 if (!svn.Resolve(data->path, result, FALSE))
1704 {
1705 CMessageBox::Show(m_hWnd, svn.GetLastErrorMessage(), _T("TortoiseGit"), MB_ICONERROR);
1706 DialogEnableWindow(IDOK, TRUE);
1707 break;
1708 }
1709 else
1710 {
1711 data->color = ::GetSysColor(COLOR_WINDOWTEXT);
1712 data->action = svn_wc_notify_resolved;
1713 data->sActionColumnText.LoadString(IDS_SVNACTION_RESOLVE);
1714 data->bConflictedActionItem = false;
1715 m_nConflicts--;
1716
1717 if (m_nConflicts==0)
1718 {
1719 // When the last conflict is resolved we remove
1720 // the warning which we assume is in the last line.
1721 int nIndex = m_ProgList.GetItemCount()-1;
1722 VERIFY(m_ProgList.DeleteItem(nIndex));
1723
1724 delete m_arData[nIndex];
1725 m_arData.pop_back();
1726 }
1727 sResolvedPaths += data->path.GetWinPathString() + _T("\n");
1728 }
1729 }
1730 }
1731 }
1732 m_ProgList.Invalidate();
1733 CString info = BuildInfoString();
1734 SetDlgItemText(IDC_INFOTEXT, info);
1735
1736 if (!sResolvedPaths.IsEmpty())
1737 {
1738 CString msg;
1739 msg.Format(IDS_SVNPROGRESS_RESOLVED, (LPCTSTR)sResolvedPaths);
1740 CMessageBox::Show(m_hWnd, msg, _T("TortoiseGit"), MB_OK | MB_ICONINFORMATION);
1741 }
1742 }
1743 break;
1744 case ID_LOG:
1745 {
1746 svn_revnum_t rev = m_RevisionEnd;
1747 if (!data->basepath.IsEmpty())
1748 {
1749 StringRevMap::iterator it = m_FinishedRevMap.find(data->basepath.GetSVNApiPath(pool));
1750 if (it != m_FinishedRevMap.end())
1751 rev = it->second;
1752 }
1753 CLogDlg dlg;
1754 // fetch the log from HEAD, not the revision we updated to:
1755 // the path might be inside an external folder which has its own
1756 // revisions.
1757 CString sPath = GetPathFromColumnText(data->sPathColumnText);
1758 dlg.SetParams(CTGitPath(sPath), SVNRev(), SVNRev::REV_HEAD, 1, -1, TRUE);
1759 dlg.DoModal();
1760 }
1761 break;
1762 case ID_OPENWITH:
1763 bOpenWith = true;
1764 case ID_OPEN:
1765 {
1766 int ret = 0;
1767 CString sWinPath = GetPathFromColumnText(data->sPathColumnText);
1768 if (!bOpenWith)
1769 ret = (int)ShellExecute(this->m_hWnd, NULL, (LPCTSTR)sWinPath, NULL, NULL, SW_SHOWNORMAL);
1770 if ((ret <= HINSTANCE_ERROR)||bOpenWith)
1771 {
1772 CString cmd = _T("RUNDLL32 Shell32,OpenAs_RunDLL ");
1773 cmd += sWinPath + _T(" ");
1774 CAppUtils::LaunchApplication(cmd, NULL, false);
1775 }
1776 }
1777 }
1778 DialogEnableWindow(IDOK, TRUE);
1779 theApp.DoWaitCursor(-1);
1780 } // if (bAdded)
1781 }
1782 }
1783 }
1784 #endif
1785 }
1786
1787 void CGitProgressDlg::OnEnSetfocusInfotext()
1788 {
1789 CString sTemp;
1790 GetDlgItemText(IDC_INFOTEXT, sTemp);
1791 if (sTemp.IsEmpty())
1792 GetDlgItem(IDC_INFOTEXT)->HideCaret();
1793 }
1794
1795 void CGitProgressDlg::OnLvnBegindragSvnprogress(NMHDR* , LRESULT *pResult)
1796 {
1797 //LPNMLISTVIEW pNMLV = reinterpret_cast<LPNMLISTVIEW>(pNMHDR);
1798 #if 0
1799 int selIndex = m_ProgList.GetSelectionMark();
1800 if (selIndex < 0)
1801 return;
1802
1803 CDropFiles dropFiles; // class for creating DROPFILES struct
1804
1805 int index;
1806 POSITION pos = m_ProgList.GetFirstSelectedItemPosition();
1807 while ( (index = m_ProgList.GetNextSelectedItem(pos)) >= 0 )
1808 {
1809 NotificationData * data = m_arData[index];
1810
1811 if ( data->kind==svn_node_file || data->kind==svn_node_dir )
1812 {
1813 CString sPath = GetPathFromColumnText(data->sPathColumnText);
1814
1815 dropFiles.AddFile( sPath );
1816 }
1817 }
1818
1819 if ( dropFiles.GetCount()>0 )
1820 {
1821 dropFiles.CreateStructure();
1822 }
1823 #endif
1824 *pResult = 0;
1825 }
1826
1827 void CGitProgressDlg::OnSize(UINT nType, int cx, int cy)
1828 {
1829 CResizableStandAloneDialog::OnSize(nType, cx, cy);
1830 if ((nType == SIZE_RESTORED)&&(m_bLastVisible))
1831 {
1832 if(!m_ProgList.m_hWnd)
1833 return;
1834
1835 int count = m_ProgList.GetItemCount();
1836 if (count > 0)
1837 m_ProgList.EnsureVisible(count-1, false);
1838 }
1839 }
1840
1841 //////////////////////////////////////////////////////////////////////////
1842 /// commands
1843 //////////////////////////////////////////////////////////////////////////
1844 bool CGitProgressDlg::CmdAdd(CString& sWindowTitle, bool& localoperation)
1845 {
1846 localoperation = true;
1847 sWindowTitle.LoadString(IDS_PROGRS_TITLE_ADD);
1848 CAppUtils::SetWindowTitle(m_hWnd, m_targetPathList.GetCommonRoot().GetUIPathString(), sWindowTitle);
1849 SetBackgroundImage(IDI_ADD_BKG);
1850 ReportCmd(CString(MAKEINTRESOURCE(IDS_PROGRS_CMD_ADD)));
1851
1852 if (CRegDWORD(_T("Software\\TortoiseGit\\UseLibgit2"), TRUE) == TRUE)
1853 {
1854 git_repository *repo = NULL;
1855 git_index *index;
1856
1857 CStringA gitdir = CUnicodeUtils::GetMulti(CTGitPath(g_Git.m_CurrentDir).GetGitPathString(), CP_UTF8);
1858 if (git_repository_open(&repo, gitdir.GetBuffer()))
1859 {
1860 gitdir.ReleaseBuffer();
1861 ReportGitError();
1862 return false;
1863 }
1864 gitdir.ReleaseBuffer();
1865
1866 git_config * config;
1867 git_config_new(&config);
1868
1869 CStringA projectConfigA = CUnicodeUtils::GetMulti(g_Git.GetGitLocalConfig(), CP_UTF8);
1870 if (git_config_add_file_ondisk(config, projectConfigA.GetBuffer(), 4, FALSE))
1871 {
1872 projectConfigA.ReleaseBuffer();
1873 ReportGitError();
1874 git_config_free(config);
1875 git_repository_free(repo);
1876 return false;
1877 }
1878 projectConfigA.ReleaseBuffer();
1879 CString globalConfig = g_Git.GetGitGlobalConfig();
1880 if (PathFileExists(globalConfig))
1881 {
1882 CStringA globalConfigA = CUnicodeUtils::GetMulti(globalConfig, CP_UTF8);
1883 if (git_config_add_file_ondisk(config, globalConfigA.GetBuffer(), 3, FALSE))
1884 {
1885 globalConfigA.ReleaseBuffer();
1886 ReportGitError();
1887 git_config_free(config);
1888 git_repository_free(repo);
1889 return false;
1890 }
1891 globalConfigA.ReleaseBuffer();
1892 }
1893 CString globalXDGConfig = g_Git.GetGitGlobalXDGConfig();
1894 if (PathFileExists(globalXDGConfig))
1895 {
1896 CStringA globalXDGConfigA = CUnicodeUtils::GetMulti(globalXDGConfig, CP_UTF8);
1897 if (git_config_add_file_ondisk(config, globalXDGConfigA.GetBuffer(), 2, FALSE))
1898 {
1899 globalXDGConfigA.ReleaseBuffer();
1900 ReportGitError();
1901 git_config_free(config);
1902 git_repository_free(repo);
1903 return false;
1904 }
1905 globalXDGConfigA.ReleaseBuffer();
1906 }
1907 CString systemConfig = g_Git.GetGitSystemConfig();
1908 if (!systemConfig.IsEmpty())
1909 {
1910 CStringA systemConfigA = CUnicodeUtils::GetMulti(systemConfig, CP_UTF8);
1911 if (git_config_add_file_ondisk(config, systemConfigA.GetBuffer(), 1, FALSE))
1912 {
1913 systemConfigA.ReleaseBuffer();
1914 ReportGitError();
1915 git_config_free(config);
1916 git_repository_free(repo);
1917 return false;
1918 }
1919 systemConfigA.ReleaseBuffer();
1920 }
1921
1922 git_repository_set_config(repo, config);
1923
1924 if (git_repository_index(&index, repo))
1925 {
1926 ReportGitError();
1927 git_repository_free(repo);
1928 return false;
1929 }
1930 if (git_index_read(index))
1931 {
1932 ReportGitError();
1933 git_index_free(index);
1934 git_repository_free(repo);
1935 return false;
1936 }
1937
1938 for (int i = 0; i < m_targetPathList.GetCount(); ++i)
1939 {
1940 if (git_index_add_bypath(index, CStringA(CUnicodeUtils::GetMulti(m_targetPathList[i].GetGitPathString(), CP_UTF8)).GetBuffer()))
1941 {
1942 ReportGitError();
1943 git_index_free(index);
1944 git_repository_free(repo);
1945 return false;
1946 }
1947 Notify(m_targetPathList[i],git_wc_notify_add);
1948 }
1949
1950 if (git_index_write(index))
1951 {
1952 ReportGitError();
1953 git_index_free(index);
1954 git_repository_free(repo);
1955 return false;
1956 }
1957
1958 git_index_free(index);
1959 git_repository_free(repo);
1960 }
1961 else
1962 {
1963 CMassiveGitTask mgt(L"add -f");
1964 mgt.ExecuteWithNotify(&m_targetPathList, m_bCancelled, git_wc_notify_add, this, &CGitProgressDlg::Notify);
1965 }
1966
1967 CShellUpdater::Instance().AddPathsForUpdate(m_targetPathList);
1968
1969 this->GetDlgItem(IDC_LOGBUTTON)->SetWindowText(_T("Commit ..."));
1970 this->GetDlgItem(IDC_LOGBUTTON)->ShowWindow(SW_SHOW);
1971 return true;
1972 }
1973
1974 bool CGitProgressDlg::CmdCopy(CString& /*sWindowTitle*/, bool& /*localoperation*/)
1975 {
1976 #if 0
1977 ASSERT(m_targetPathList.GetCount() == 1);
1978 sWindowTitle.LoadString(IDS_PROGRS_TITLE_COPY);
1979 SetWindowText(sWindowTitle); // needs to be updated, see TSVN rev. 21375
1980 SetBackgroundImage(IDI_COPY_BKG);
1981
1982 CString sCmdInfo;
1983 sCmdInfo.Format(IDS_PROGRS_CMD_COPY,
1984 m_targetPathList[0].IsUrl() ? (LPCTSTR)m_targetPathList[0].GetSVNPathString() : m_targetPathList[0].GetWinPath(),
1985 (LPCTSTR)m_url.GetSVNPathString(), (LPCTSTR)m_Revision.ToString());
1986 ReportCmd(sCmdInfo);
1987
1988 if (!Copy(m_targetPathList, m_url, m_Revision, m_pegRev, m_sMessage))
1989 {
1990 ReportSVNError();
1991 return false;
1992 }
1993 if (m_options & ProgOptSwitchAfterCopy)
1994 {
1995 sCmdInfo.Format(IDS_PROGRS_CMD_SWITCH,
1996 m_targetPathList[0].GetWinPath(),
1997 (LPCTSTR)m_url.GetSVNPathString(), (LPCTSTR)m_Revision.ToString());
1998 ReportCmd(sCmdInfo);
1999 if (!Switch(m_targetPathList[0], m_url, SVNRev::REV_HEAD, SVNRev::REV_HEAD, m_depth, TRUE, m_options & ProgOptIgnoreExternals))
2000 {
2001 if (!Switch(m_targetPathList[0], m_url, SVNRev::REV_HEAD, m_Revision, m_depth, TRUE, m_options & ProgOptIgnoreExternals))
2002 {
2003 ReportSVNError();
2004 return false;
2005 }
2006 }
2007 }
2008 else
2009 {
2010 if (SVN::PathIsURL(m_url))
2011 {
2012 CString sMsg(MAKEINTRESOURCE(IDS_PROGRS_COPY_WARNING));
2013 ReportNotification(sMsg);
2014 }
2015 }
2016 #endif
2017 return true;
2018 }
2019
2020 bool CGitProgressDlg::CmdExport(CString& /*sWindowTitle*/, bool& /*localoperation*/)
2021 {
2022 #if 0
2023 ASSERT(m_targetPathList.GetCount() == 1);
2024 sWindowTitle.LoadString(IDS_PROGRS_TITLE_EXPORT);
2025 sWindowTitle = m_url.GetUIFileOrDirectoryName()+_T(" - ")+sWindowTitle;
2026 SetWindowText(sWindowTitle); // needs to be updated, see TSVN rev. 21375
2027 SetBackgroundImage(IDI_EXPORT_BKG);
2028 CString eol;
2029 if (m_options & ProgOptEolCRLF)
2030 eol = _T("CRLF");
2031 if (m_options & ProgOptEolLF)
2032 eol = _T("LF");
2033 if (m_options & ProgOptEolCR)
2034 eol = _T("CR");
2035 ReportCmd(CString(MAKEINTRESOURCE(IDS_PROGRS_CMD_EXPORT)));
2036 if (!Export(m_url, m_targetPathList[0], m_Revision, m_Revision, TRUE, m_options & ProgOptIgnoreExternals, m_depth, NULL, FALSE, eol))
2037 {
2038 ReportSVNError();
2039 return false;
2040 }
2041 #endif
2042 return true;
2043 }
2044
2045 bool CGitProgressDlg::CmdRename(CString& /*sWindowTitle*/, bool& /*localoperation*/)
2046 {
2047 #if 0
2048 ASSERT(m_targetPathList.GetCount() == 1);
2049 if ((!m_targetPathList[0].IsUrl())&&(!m_url.IsUrl()))
2050 localoperation = true;
2051 sWindowTitle.LoadString(IDS_PROGRS_TITLE_RENAME);
2052 SetWindowText(sWindowTitle); // needs to be updated, see TSVN rev. 21375
2053 SetBackgroundImage(IDI_RENAME_BKG);
2054 ReportCmd(CString(MAKEINTRESOURCE(IDS_PROGRS_CMD_RENAME)));
2055 if (!Move(m_targetPathList, m_url, m_Revision, m_sMessage))
2056 {
2057 ReportSVNError();
2058 return false;
2059 }
2060 #endif
2061 return true;
2062 }
2063
2064 bool CGitProgressDlg::CmdResolve(CString& sWindowTitle, bool& localoperation)
2065 {
2066
2067 localoperation = true;
2068 ASSERT(m_targetPathList.GetCount() == 1);
2069 sWindowTitle.LoadString(IDS_PROGRS_TITLE_RESOLVE);
2070 CAppUtils::SetWindowTitle(m_hWnd, m_targetPathList.GetCommonRoot().GetUIPathString(), sWindowTitle);
2071 SetBackgroundImage(IDI_RESOLVE_BKG);
2072 // check if the file may still have conflict markers in it.
2073 //BOOL bMarkers = FALSE;
2074
2075 for (int i = 0; i < m_targetPathList.GetCount(); ++i)
2076 {
2077 CString cmd,out,tempmergefile;
2078 cmd.Format(_T("git.exe add -f -- \"%s\""),m_targetPathList[i].GetGitPathString());
2079 if (g_Git.Run(cmd, &out, CP_UTF8))
2080 {
2081 CMessageBox::Show(NULL,out,_T("TortoiseGit"),MB_OK|MB_ICONERROR);
2082 m_bErrorsOccurred=true;
2083 return false;
2084 }
2085
2086 CAppUtils::RemoveTempMergeFile((CTGitPath &)m_targetPathList[i]);
2087
2088 Notify(m_targetPathList[i],git_wc_notify_resolved);
2089 }
2090 #if 0
2091 if ((m_options & ProgOptSkipConflictCheck) == 0)
2092 {
2093 try
2094 {
2095 for (INT_PTR fileindex=0; (fileindex<m_targetPathList.GetCount()) && (bMarkers==FALSE); ++fileindex)
2096 {
2097 if (!m_targetPathList[fileindex].IsDirectory())
2098 {
2099 CStdioFile file(m_targetPathList[fileindex].GetWinPath(), CFile::typeBinary | CFile::modeRead);
2100 CString strLine = _T("");
2101 while (file.ReadString(strLine))
2102 {
2103 if (strLine.Find(_T("<<<<<<<"))==0)
2104 {
2105 bMarkers = TRUE;
2106 break;
2107 }
2108 }
2109 file.Close();
2110 }
2111 }
2112 }
2113 catch (CFileException* pE)
2114 {
2115 TRACE(_T("CFileException in Resolve!\n"));
2116 TCHAR error[10000] = {0};
2117 pE->GetErrorMessage(error, 10000);
2118 ReportError(error);
2119 pE->Delete();
2120 return false;
2121 }
2122 }
2123 if (bMarkers)
2124 {
2125 if (CMessageBox::Show(m_hWnd, IDS_PROGRS_REVERTMARKERS, IDS_APPNAME, MB_YESNO | MB_ICONQUESTION)==IDYES)
2126 {
2127 ReportCmd(CString(MAKEINTRESOURCE(IDS_PROGRS_CMD_RESOLVE)));
2128 for (INT_PTR fileindex=0; fileindex<m_targetPathList.GetCount(); ++fileindex)
2129 Resolve(m_targetPathList[fileindex], svn_wc_conflict_choose_merged, true);
2130 }
2131 }
2132 else
2133 {
2134 ReportCmd(CString(MAKEINTRESOURCE(IDS_PROGRS_CMD_RESOLVE)));
2135 for (INT_PTR fileindex=0; fileindex<m_targetPathList.GetCount(); ++fileindex)
2136 Resolve(m_targetPathList[fileindex], svn_wc_conflict_choose_merged, true);
2137 }
2138 #endif
2139 CShellUpdater::Instance().AddPathsForUpdate(m_targetPathList);
2140
2141 this->GetDlgItem(IDC_LOGBUTTON)->SetWindowText(_T("Commit ..."));
2142 this->GetDlgItem(IDC_LOGBUTTON)->ShowWindow(SW_SHOW);
2143
2144 return true;
2145 }
2146
2147 bool CGitProgressDlg::CmdRevert(CString& sWindowTitle, bool& localoperation)
2148 {
2149
2150 localoperation = true;
2151 sWindowTitle.LoadString(IDS_PROGRS_TITLE_REVERT);
2152 CAppUtils::SetWindowTitle(m_hWnd, m_targetPathList.GetCommonRoot().GetUIPathString(), sWindowTitle);
2153 SetBackgroundImage(IDI_REVERT_BKG);
2154
2155 CTGitPathList delList;
2156 for (int i = 0; i < m_selectedPaths.GetCount(); ++i)
2157 {
2158 CTGitPath path;
2159 int action;
2160 path.SetFromWin(g_Git.m_CurrentDir+_T("\\")+m_selectedPaths[i].GetWinPath());
2161 action = m_selectedPaths[i].m_Action;
2162 /* rename file can't delete because it needs original file*/
2163 if((!(action & CTGitPath::LOGACTIONS_ADDED)) &&
2164 (!(action & CTGitPath::LOGACTIONS_REPLACED)))
2165 delList.AddPath(path);
2166 }
2167 if (DWORD(CRegDWORD(_T("Software\\TortoiseGit\\RevertWithRecycleBin"), TRUE)))
2168 delList.DeleteAllFiles(true);
2169
2170 ReportCmd(CString(MAKEINTRESOURCE(IDS_PROGRS_CMD_REVERT)));
2171 for (int i = 0; i < m_selectedPaths.GetCount(); ++i)
2172 {
2173 if(g_Git.Revert(_T("HEAD"), (CTGitPath&)m_selectedPaths[i]))
2174 {
2175 CMessageBox::Show(NULL,_T("Revert Fail"),_T("TortoiseGit"),MB_OK|MB_ICONERROR);
2176 m_bErrorsOccurred=true;
2177 return false;
2178 }
2179 Notify(m_selectedPaths[i],git_wc_notify_revert);
2180 }
2181
2182 CShellUpdater::Instance().AddPathsForUpdate(m_selectedPaths);
2183
2184 return true;
2185 }
2186
2187 bool CGitProgressDlg::CmdSwitch(CString& /*sWindowTitle*/, bool& /*localoperation*/)
2188 {
2189 #if 0
2190 ASSERT(m_targetPathList.GetCount() == 1);
2191 SVNStatus st;
2192 sWindowTitle.LoadString(IDS_PROGRS_TITLE_SWITCH);
2193 SetWindowText(sWindowTitle); // needs to be updated, see TSVN rev. 21375
2194 SetBackgroundImage(IDI_SWITCH_BKG);
2195 LONG rev = 0;
2196 if (st.GetStatus(m_targetPathList[0]) != (-2))
2197 {
2198 if (st.status->entry != NULL)
2199 {
2200 rev = st.status->entry->revision;
2201 }
2202 }
2203
2204 CString sCmdInfo;
2205 sCmdInfo.Format(IDS_PROGRS_CMD_SWITCH,
2206 m_targetPathList[0].GetWinPath(), (LPCTSTR)m_url.GetSVNPathString(),
2207 (LPCTSTR)m_Revision.ToString());
2208 ReportCmd(sCmdInfo);
2209
2210 bool depthIsSticky = true;
2211 if (m_depth == svn_depth_unknown)
2212 depthIsSticky = false;
2213 if (!Switch(m_targetPathList[0], m_url, m_Revision, m_Revision, m_depth, depthIsSticky, m_options & ProgOptIgnoreExternals))
2214 {
2215 ReportSVNError();
2216 return false;
2217 }
2218 m_UpdateStartRevMap[m_targetPathList[0].GetSVNApiPath(pool)] = rev;
2219 if ((m_RevisionEnd >= 0)&&(rev >= 0)
2220 &&((LONG)m_RevisionEnd > (LONG)rev))
2221 {
2222 GetDlgItem(IDC_LOGBUTTON)->ShowWindow(SW_SHOW);
2223 }
2224 #endif
2225 return true;
2226 }
2227
2228 void CGitProgressDlg::OnBnClickedNoninteractive()
2229 {
2230 LRESULT res = ::SendMessage(GetDlgItem(IDC_NONINTERACTIVE)->GetSafeHwnd(), BM_GETCHECK, 0, 0);
2231 m_AlwaysConflicted = (res == BST_CHECKED);
2232 CRegDWORD nonint = CRegDWORD(_T("Software\\TortoiseGit\\MergeNonInteractive"), FALSE);
2233 nonint = m_AlwaysConflicted;
2234 }
2235
2236 CString CGitProgressDlg::GetPathFromColumnText(const CString& sColumnText)
2237 {
2238 CString sPath = CPathUtils::ParsePathInString(sColumnText);
2239 if (sPath.Find(':')<0)
2240 {
2241 // the path is not absolute: add the common root of all paths to it
2242 sPath = m_targetPathList.GetCommonRoot().GetDirectory().GetWinPathString() + _T("\\") + CPathUtils::ParsePathInString(sColumnText);
2243 }
2244 return sPath;
2245 }
2246
2247 bool CGitProgressDlg::CmdSendMail(CString& sWindowTitle, bool& /*localoperation*/)
2248 {
2249 sWindowTitle.LoadString(IDS_PROGRS_TITLE_SENDMAIL);
2250 CAppUtils::SetWindowTitle(m_hWnd, m_targetPathList.GetCommonRoot().GetUIPathString(), sWindowTitle);
2251 //SetBackgroundImage(IDI_ADD_BKG);
2252 ReportCmd(CString(MAKEINTRESOURCE(IDS_PROGRS_CMD_SENDMAIL)));
2253 bool ret=true;
2254 if(this->m_SendMailFlags&SENDMAIL_COMBINED)
2255 {
2256 CString error;
2257 CTGitPath path;
2258 Notify(path,git_wc_notify_sendmail_start);
2259 CString err;
2260 int retry=0;
2261 while(retry <3)
2262 {
2263 if(!!CPatch::SendPatchesCombined(m_targetPathList,m_SendMailTO,m_SendMailCC,m_SendMailSubject,!!(this->m_SendMailFlags&SENDMAIL_ATTACHMENT),!!(this->m_SendMailFlags&SENDMAIL_MAPI),&err))
2264 {
2265 Notify(path,git_wc_notify_sendmail_error,ret,&err);
2266 ret = false;
2267 }
2268 else
2269 {
2270 break;
2271 }
2272
2273 ++retry;
2274 if (retry < 3)
2275 Notify(path,git_wc_notify_sendmail_retry,ret,&err);
2276 Sleep(2000);
2277 if(m_bCancelled)
2278 {
2279 CString str(_T("User Canceled"));
2280 Notify(path,git_wc_notify_sendmail_error,ret,&str);
2281 return false;
2282 }
2283 }
2284 if (ret)
2285 Notify(path,git_wc_notify_sendmail_done,ret);
2286 }
2287 else
2288 {
2289 for (int i = 0; ret && i < m_targetPathList.GetCount(); ++i)
2290 {
2291 CPatch patch;
2292 Notify(m_targetPathList[i],git_wc_notify_sendmail_start);
2293
2294 int retry=0;
2295 while(retry<3)
2296 {
2297 if(!!patch.Send((CString&)m_targetPathList[i].GetWinPathString(),this->m_SendMailTO,
2298 this->m_SendMailCC,!!(this->m_SendMailFlags&SENDMAIL_ATTACHMENT),!!(this->m_SendMailFlags&SENDMAIL_MAPI)))
2299 {
2300 Notify(m_targetPathList[i],git_wc_notify_sendmail_error,ret,&patch.m_LastError);
2301 ret = false;
2302
2303 }
2304 else
2305 {
2306 ret = true;
2307 break;
2308 }
2309 ++retry;
2310 if (retry < 3)
2311 Notify(m_targetPathList[i],git_wc_notify_sendmail_retry,ret,&patch.m_LastError);
2312 Sleep(2000);
2313 if(m_bCancelled)
2314 {
2315 CString str(_T("User Canceled"));
2316 Notify(m_targetPathList[i],git_wc_notify_sendmail_error,ret,&str);
2317 return false;
2318 }
2319 }
2320 if (ret)
2321 Notify(m_targetPathList[i],git_wc_notify_sendmail_done,ret);
2322 }
2323 }
2324 return ret;
2325 }
2326
2327 LRESULT CGitProgressDlg::OnTaskbarBtnCreated(WPARAM /*wParam*/, LPARAM /*lParam*/)
2328 {
2329 m_pTaskbarList.Release();
2330 m_pTaskbarList.CoCreateInstance(CLSID_TaskbarList);
2331 return 0;
2332 }
Windows Explorer Extension to Operate Git