src/TortoiseProc/GitProgressDlg.cpp

   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 "SmartHandle.h"
  47
  48
  49 IMPLEMENT_DYNAMIC(CGitProgressDlg, CResizableStandAloneDialog)
  50 CGitProgressDlg::CGitProgressDlg(CWnd* pParent /*=NULL*/)
  51         : CResizableStandAloneDialog(CGitProgressDlg::IDD, pParent)
  52
  53 #if 0
  54         , m_Revision(_T("HEAD"))
  55         //, m_RevisionEnd(0)
  56         , m_bLockWarning(false)
  57         , m_bLockExists(false)
  58         , m_bThreadRunning(FALSE)
  59         , m_nConflicts(0)
  60         , m_bMergesAddsDeletesOccurred(FALSE)
  61         , m_dwCloseOnEnd((DWORD)-1)
  62         , m_bFinishedItemAdded(false)
  63         , m_bLastVisible(false)
  64 //      , m_depth(svn_depth_unknown)
  65         , m_itemCount(-1)
  66         , m_itemCountTotal(-1)
  67         , m_AlwaysConflicted(false)
  68         , m_BugTraqProvider(NULL)
  69         , sDryRun(MAKEINTRESOURCE(IDS_PROGRS_DRYRUN))
  70         , sRecordOnly(MAKEINTRESOURCE(IDS_MERGE_RECORDONLY))
  71 #endif
  72 {
  73 }
  74
  75 CGitProgressDlg::~CGitProgressDlg()
  76 {
  77 }
  78
  79 void CGitProgressDlg::DoDataExchange(CDataExchange* pDX)
  80 {
  81         CResizableStandAloneDialog::DoDataExchange(pDX);
  82         DDX_Control(pDX, IDC_SVNPROGRESS, m_ProgList);
  83         DDX_Control(pDX, IDC_TITLE_ANIMATE, m_Animate);
  84         DDX_Control(pDX, IDC_PROGRESSBAR, m_ProgCtrl);
  85         DDX_Control(pDX, IDC_INFOTEXT, m_InfoCtrl);
  86         DDX_Control(pDX, IDC_PROGRESSLABEL, m_ProgLableCtrl);
  87 }
  88
  89 BEGIN_MESSAGE_MAP(CGitProgressDlg, CResizableStandAloneDialog)
  90         ON_BN_CLICKED(IDC_LOGBUTTON, OnBnClickedLogbutton)
  91         ON_WM_CLOSE()
  92         ON_WM_SETCURSOR()
  93         ON_EN_SETFOCUS(IDC_INFOTEXT, &CGitProgressDlg::OnEnSetfocusInfotext)
  94         ON_BN_CLICKED(IDC_NONINTERACTIVE, &CGitProgressDlg::OnBnClickedNoninteractive)
  95         ON_WM_CTLCOLOR()
  96         ON_MESSAGE(WM_PROG_CMD_FINISH, OnCmdEnd)
  97         ON_MESSAGE(WM_PROG_CMD_START, OnCmdStart)
  98 END_MESSAGE_MAP()
  99
 100
 101
 102 BOOL CGitProgressDlg::OnInitDialog()
 103 {
 104         __super::OnInitDialog();
 105
 106
 107         UpdateData(FALSE);
 108
 109         AddAnchor(IDC_SVNPROGRESS, TOP_LEFT, BOTTOM_RIGHT);
 110         AddAnchor(IDC_TITLE_ANIMATE, TOP_LEFT, BOTTOM_RIGHT);
 111         AddAnchor(IDC_PROGRESSLABEL, BOTTOM_LEFT, BOTTOM_CENTER);
 112         AddAnchor(IDC_PROGRESSBAR, BOTTOM_CENTER, BOTTOM_RIGHT);
 113         AddAnchor(IDC_INFOTEXT, BOTTOM_LEFT, BOTTOM_RIGHT);
 114         AddAnchor(IDC_NONINTERACTIVE, BOTTOM_LEFT, BOTTOM_RIGHT);
 115         AddAnchor(IDCANCEL, BOTTOM_RIGHT);
 116         AddAnchor(IDOK, BOTTOM_RIGHT);
 117         AddAnchor(IDC_LOGBUTTON, BOTTOM_RIGHT);
 118         //SetPromptParentWindow(this->m_hWnd);
 119
 120         m_Animate.Open(IDR_DOWNLOAD);
 121         m_ProgList.m_pAnimate = &m_Animate;
 122         m_ProgList.m_pProgControl = &m_ProgCtrl;
 123         m_ProgList.m_pProgressLabelCtrl = &m_ProgLableCtrl;
 124         m_ProgList.m_pInfoCtrl = &m_InfoCtrl;
 125
 126         if (hWndExplorer)
 127                 CenterWindow(CWnd::FromHandle(hWndExplorer));
 128         EnableSaveRestore(_T("GITProgressDlg"));
 129
 130         m_background_brush.CreateSolidBrush(GetSysColor(COLOR_WINDOW));
 131         m_ProgList.Init();
 132
 133         return TRUE;
 134 }
 135
 136
 137
 138 void CGitProgressDlg::OnBnClickedLogbutton()
 139 {
 140         switch(m_ProgList.m_Command)
 141         {
 142         case CGitProgressList::GitProgress_Add:
 143         case CGitProgressList::GitProgress_Resolve:
 144                 {
 145                         CString cmd = _T(" /command:commit");
 146                         cmd += _T(" /path:\"")+g_Git.m_CurrentDir+_T("\"");
 147
 148                         CAppUtils::RunTortoiseGitProc(cmd);
 149                         this->EndDialog(IDOK);
 150                         break;
 151                 }
 152         }
 153 #if 0
 154         if (m_targetPathList.GetCount() != 1)
 155                 return;
 156         StringRevMap::iterator it = m_UpdateStartRevMap.begin();
 157         svn_revnum_t rev = -1;
 158         if (it != m_UpdateStartRevMap.end())
 159         {
 160                 rev = it->second;
 161         }
 162         CLogDlg dlg;
 163         dlg.SetParams(m_targetPathList[0], m_RevisionEnd, m_RevisionEnd, rev, 0, TRUE);
 164         dlg.DoModal();
 165 #endif
 166 }
 167
 168
 169 void CGitProgressDlg::OnClose()
 170 {
 171         DialogEnableWindow(IDCANCEL, TRUE);
 172         __super::OnClose();
 173 }
 174
 175 void CGitProgressDlg::OnOK()
 176 {
 177         if ((m_ProgList.IsCancelled())&&(!m_ProgList.IsRunning()))
 178         {
 179                 // I have made this wait a sensible amount of time (10 seconds) for the thread to finish
 180                 // You must be careful in the thread that after posting the WM_COMMAND/IDOK message, you
 181                 // don't do any more operations on the window which might require message passing
 182                 // If you try to send windows messages once we're waiting here, then the thread can't finished
 183                 // because the Window's message loop is blocked at this wait
 184                 WaitForSingleObject(m_ProgList.m_pThread->m_hThread, 10000);
 185                 __super::OnOK();
 186         }
 187         m_ProgList.Cancel();
 188 }
 189
 190 void CGitProgressDlg::OnCancel()
 191 {
 192         if ((m_ProgList.IsCancelled())&&(!m_ProgList.IsRunning()))
 193                 __super::OnCancel();
 194         m_ProgList.Cancel();
 195 }
 196
 197
 198 BOOL CGitProgressDlg::OnSetCursor(CWnd* pWnd, UINT nHitTest, UINT message)
 199 {
 200         if (!GetDlgItem(IDOK)->IsWindowEnabled())
 201         {
 202                 // only show the wait cursor over the list control
 203                 if ((pWnd)&&(pWnd == GetDlgItem(IDC_SVNPROGRESS)))
 204                 {
 205                         HCURSOR hCur = LoadCursor(NULL, MAKEINTRESOURCE(IDC_WAIT));
 206                         SetCursor(hCur);
 207                         return TRUE;
 208                 }
 209         }
 210         HCURSOR hCur = LoadCursor(NULL, MAKEINTRESOURCE(IDC_ARROW));
 211         SetCursor(hCur);
 212         return CResizableStandAloneDialog::OnSetCursor(pWnd, nHitTest, message);
 213 }
 214
 215 BOOL CGitProgressDlg::PreTranslateMessage(MSG* pMsg)
 216 {
 217         if (pMsg->message == WM_KEYDOWN)
 218         {
 219                 if (pMsg->wParam == VK_ESCAPE)
 220                 {
 221                         // pressing the ESC key should close the dialog. But since we disabled the escape
 222                         // key (so the user doesn't get the idea that he could simply undo an e.g. update)
 223                         // this won't work.
 224                         // So if the user presses the ESC key, change it to VK_RETURN so the dialog gets
 225                         // the impression that the OK button was pressed.
 226                         if ((!m_ProgList.IsRunning())&&(!GetDlgItem(IDCANCEL)->IsWindowEnabled())
 227                                 &&(GetDlgItem(IDOK)->IsWindowEnabled())&&(GetDlgItem(IDOK)->IsWindowVisible()))
 228                         {
 229                                 // since we convert ESC to RETURN, make sure the OK button has the focus.
 230                                 GetDlgItem(IDOK)->SetFocus();
 231                                 pMsg->wParam = VK_RETURN;
 232                         }
 233                 }
 234         }
 235         return __super::PreTranslateMessage(pMsg);
 236 }
 237
 238
 239
 240 void CGitProgressDlg::OnEnSetfocusInfotext()
 241 {
 242         CString sTemp;
 243         GetDlgItemText(IDC_INFOTEXT, sTemp);
 244         if (sTemp.IsEmpty())
 245                 GetDlgItem(IDC_INFOTEXT)->HideCaret();
 246 }
 247
 248
 249 void CGitProgressDlg::OnBnClickedNoninteractive()
 250 {
 251         LRESULT res = ::SendMessage(GetDlgItem(IDC_NONINTERACTIVE)->GetSafeHwnd(), BM_GETCHECK, 0, 0);
 252         m_ProgList.m_AlwaysConflicted = (res == BST_CHECKED);
 253         CRegDWORD nonint = CRegDWORD(_T("Software\\TortoiseGit\\MergeNonInteractive"), FALSE);
 254         nonint = m_ProgList.m_AlwaysConflicted;
 255 }
 256
 257 LRESULT CGitProgressDlg::OnCtlColorStatic(WPARAM wParam, LPARAM lParam)
 258 {
 259         HDC hDC = (HDC)wParam;
 260         HWND hwndCtl = (HWND)lParam;
 261
 262         if (::GetDlgCtrlID(hwndCtl) == IDC_TITLE_ANIMATE)
 263         {
 264                 CDC *pDC = CDC::FromHandle(hDC);
 265                 pDC->SetBkColor(GetSysColor(COLOR_WINDOW));
 266                 pDC->SetBkMode(TRANSPARENT);
 267                 return (LRESULT)(HBRUSH)m_background_brush.GetSafeHandle();
 268         }
 269         return FALSE;
 270 }
 271
 272 HBRUSH CGitProgressDlg::OnCtlColor(CDC* pDC, CWnd* pWnd, UINT nCtlColor)
 273 {
 274         HBRUSH hbr;
 275         if (pWnd->GetDlgCtrlID() == IDC_TITLE_ANIMATE)
 276         {
 277                 pDC->SetBkColor(GetSysColor(COLOR_WINDOW)); // add this
 278                 pDC->SetBkMode(TRANSPARENT);
 279                 return (HBRUSH)m_background_brush.GetSafeHandle();
 280         }
 281         else
 282                 hbr = CResizableStandAloneDialog::OnCtlColor(pDC, pWnd, nCtlColor);
 283
 284         // TODO:  Return a different brush if the default is not desired
 285         return hbr;
 286 }
 287
 288 LRESULT CGitProgressDlg::OnCmdEnd(WPARAM wParam, LPARAM /*lParam*/)
 289 {
 290         DialogEnableWindow(IDCANCEL, FALSE);
 291         DialogEnableWindow(IDOK, TRUE);
 292
 293         switch(wParam)
 294         {
 295         case CGitProgressList::GitProgress_Add:
 296         case CGitProgressList::GitProgress_Revert:
 297                 this->GetDlgItem(IDC_LOGBUTTON)->SetWindowText(CString(MAKEINTRESOURCE(IDS_COMMITBUTTON)));
 298                 this->GetDlgItem(IDC_LOGBUTTON)->ShowWindow(SW_SHOW);
 299                 break;
 300         }
 301
 302         CWnd * pWndOk = GetDlgItem(IDOK);
 303         if (pWndOk && ::IsWindow(pWndOk->GetSafeHwnd()))
 304         {
 305                 SendMessage(DM_SETDEFID, IDOK);
 306                 GetDlgItem(IDOK)->SetFocus();
 307         }
 308
 309         return 0;
 310 }
 311 LRESULT CGitProgressDlg::OnCmdStart(WPARAM /*wParam*/, LPARAM /*lParam*/)
 312 {
 313         DialogEnableWindow(IDOK, FALSE);
 314         DialogEnableWindow(IDCANCEL, TRUE);
 315
 316         return 0;
 317 }